x1 = mesh.get_layer(i)[j].x1
x2 = mesh.get_layer(i)[j].x2
y1 = mesh.get_layer(i)[j].y1
y2 = mesh.get_layer(i)[j].y2
z1 = mesh.get_layer(i)[j].z1
z2 = mesh.get_layer(i)[j].z2
den = mesh.get_layer(i)[j].props
model=[geometry.Prism(x1, x2, y1, y2, z1, z2,
{'magnetization': giutils.ang2vec(1, inc, dec)})]
field = prism.tf(xp, yp, zp, model, inc, dec)
kernel.append(field)
kk=np.transpose(kernel) #kernel matrix for inversion, 500 cells * 400 points
field_mag=np.mat(kk)*np.transpose(np.mat(mag1.ravel()))
field_gra=np.mat(kernelgz)*np.transpose(np.mat(rho1.ravel()))
field_mag1 = giutils.contaminate(np.array(field_mag).ravel(), 0.05, percent = True)
field_gra1 = giutils.contaminate(np.array(field_gra).ravel(), 0.05, percent = True)
#保存正演异常
with open(graoutfile, 'w') as f:
f.write('! model 2 gravity anomlay (mGal)\n')
f.write('{}\n'.format(len(field_gra)))
for i in range(len(field_gra)):
f.write('{} {} {} {}\n'.format(yp[i],xp[i],zp[i],np.array(field_gra[i]).ravel()[0]))
with open(magoutfile, 'w') as f:
f.write('! model 2 magtotal-field magnetic anomaly (nT)\n')
f.write('{}\n'.format(len(field_mag)))
for i in range(len(field_mag)):
f.write('{} {} {} {}\n'.format(yp[i],xp[i],zp[i],np.array(field_mag[i]).ravel()[0]))
"""
GravMag: Calculating the derivatives of the gravity anomaly using FFT
"""
import matplotlib.pyplot as plt
from geoist import gridder
from geoist.inversion import geometry
from geoist.pfm import prism, pftrans, giutils
from geoist.vis import giplt
model = [geometry.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 = giutils.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 = giutils.si2eotvos(pftrans.derivx(xp, yp, giutils.mgal2si(gz), shape))
gyz = giutils.si2eotvos(pftrans.derivy(xp, yp, giutils.mgal2si(gz), shape))
gzz = giutils.si2eotvos(pftrans.derivz(xp, yp, giutils.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)
plt.figure()
plt.title("Original gravity anomaly")
plt.axis('scaled')
giplt.contourf(xp, yp, gz, shape, 15)
plt.colorbar(shrink=0.7)
giplt.m2km()
x1 = mesh.get_layer(i)[j].x1
x2 = mesh.get_layer(i)[j].x2
y1 = mesh.get_layer(i)[j].y1
y2 = mesh.get_layer(i)[j].y2
z1 = mesh.get_layer(i)[j].z1
z2 = mesh.get_layer(i)[j].z2
den = mesh.get_layer(i)[j].props
model=[geometry.Prism(x1, x2, y1, y2, z1, z2, {'density': 1000.})]
field = prism.gz(xp, yp, zp, model)
kernel.append(field)
depthz.append((z1+z2)/2.0)
kk=np.array(kernel)
kk=np.transpose(kernel) #kernel matrix for inversion, 500 cells * 400 points
field0=np.mat(kk)*np.transpose(np.mat(density.ravel()))
field = giutils.contaminate(np.array(field0).ravel(), 0.05, percent = True)
#零均值
print(field.mean())
#field = field + 300. # field.mean()
#画图
plt.figure(figsize=(16, 8))
plt.subplot(1, 2, 1)
plt.title('gravity anomlay')
plt.axis('scaled')
levels = giplt.contourf(yp * 0.001, xp * 0.001, field0, nshape, 15)
cb = plt.colorbar(orientation='horizontal')
giplt.contour(yp * 0.001, xp * 0.001, field0, nshape,
levels, clabel=False, linewidth=0.1)
plt.subplot(1, 2, 2)
# local imports
from geoist import gridder
from geoist.inversion import geometry
from geoist.pfm import prism, pftrans, giutils
from geoist.vis import giplt
model = [
geometry.Prism(-3000, -2000, -3000, -2000, 500, 2000, {'density': 1000}),
geometry.Prism(-1000, 1000, -1000, 1000, 0, 2000, {'density': -800}),
geometry.Prism(1000, 3000, 2000, 3000, 0, 1000, {'density': 900})
]
area = (-5000, 5000, -5000, 5000)
shape = (50, 50)
z0 = -100
x, y, z = gridder.regular(area, shape, z=z0)
gz = giutils.contaminate(prism.gz(x, y, z, model), 0.5, seed=0)
height = 1000 # How much higher to go
gzcontf = pftrans.upcontinue(x, y, gz, shape, height)
# Compute the true value at the new height for comparison
gztrue = prism.gz(x, y, z - height, model)
args = dict(shape=shape, levels=20, cmap=plt.cm.RdBu_r)
fig, axes = plt.subplots(1, 3, figsize=(12, 3.5))
axes = axes.ravel()
plt.sca(axes[0])
plt.title("Original")
plt.axis('scaled')
giplt.contourf(x, y, gz, **args)
plt.colorbar(pad=0).set_label('mGal')
from geoist.inversion import geometry
from geoist.pfm import prism, pftrans, giutils
from geoist.vis import giplt
# Direction of the Geomagnetic field
inc, dec = -60, 0
# Make a model with only induced magnetization
model = [
geometry.Prism(-100, 100, -100, 100, 0, 2000,
{'magnetization': giutils.ang2vec(10, inc, dec)})
]
area = (-5000, 5000, -5000, 5000)
shape = (100, 100)
z0 = -500
x, y, z = gridder.regular(area, shape, z=z0)
tf = giutils.contaminate(prism.tf(x, y, z, model, inc, dec), 1, seed=0)
# Reduce to the pole using FFT. Since there is only induced magnetization, the
# magnetization direction (sinc and sdec) is the same as the geomagnetic field
pole = pftrans.reduce_to_pole(x, y, tf, shape, inc, dec, sinc=inc, sdec=dec)
# Calculate the true value at the pole for comparison
true = prism.tf(x, y, z, model, 90, 0, pmag=giutils.ang2vec(10, 90, 0))
fig, axes = plt.subplots(1, 3, figsize=(14, 4))
for ax in axes:
ax.set_aspect('equal')
plt.sca(axes[0])
plt.title("Original total field anomaly")
giplt.contourf(y, x, tf, shape, 30, cmap=plt.cm.RdBu_r)
plt.colorbar(pad=0).set_label('nT')
giplt.m2km()
plt.sca(axes[1])
from geoist.pfm import giutils as utils
import numpy as np
import matplotlib.pyplot as plt
# Make some synthetic data to test the inversion
# The model will be a polygon.
# Reverse x because vertices must be clockwise.
xs = np.linspace(0, 100000, 100)[::-1]
depths = (-1e-15 * (xs - 50000)**4 + 8000 - 3000 * np.exp(-(xs - 70000)**2 /
(10000**2)))
depths -= depths.min() # Reduce depths to zero
props = {'density': -300}
model = Polygon(np.transpose([xs, depths]), props)
x = np.linspace(0, 100000, 100)
z = -100 * np.ones_like(x)
data = utils.contaminate(talwani.gz(x, z, [model]), 0.5, seed=0)
# Make the solver using smoothness regularization and run the inversion
misfit = PolygonalBasinGravity(x, z, data, 50, props, top=0)
regul = Smoothness1D(misfit.nparams)
solver = misfit + 1e-4 * regul
# This is a non-linear problem so we need to pick an initial estimate
initial = 3000 * np.ones(misfit.nparams)
solver.config('levmarq', initial=initial).fit()
plt.figure()
plt.subplot(2, 1, 1)
plt.plot(x, data, 'ok', label='observed')
plt.plot(x, solver[0].predicted(), '-r', linewidth=2, label='predicted')
plt.legend()
ax = plt.subplot(2, 1, 2)
giplt.polygon(model, fill='gray', alpha=0.5, label='True')
"""
# 3rd imports
import matplotlib.pyplot as plt
# local imports
from geoist import gridder
from geoist.inversion import geometry
from geoist.pfm import prism, giutils
from geoist.vis import giplt
model = [geometry.Prism(-1000, 1000, -1000, 1000, 0, 2000, {'density': 1000})]
shape = (100, 100)
xp, yp, zp = gridder.regular((-5000, 5000, -5000, 5000), shape, z=-200)
components = [prism.gxx, prism.gxy, prism.gxz,
prism.gyy, prism.gyz, prism.gzz]
print("Calculate the tensor components and contaminate with 5 Eotvos noise")
ftg = [giutils.contaminate(comp(xp, yp, zp, model), 5.0) for comp in components]
print("Plotting...")
plt.figure(figsize=(14, 6))
plt.suptitle("Contaminated FTG data")
names = ['gxx', 'gxy', 'gxz', 'gyy', 'gyz', 'gzz']
for i, data in enumerate(ftg):
plt.subplot(2, 3, i + 1)
plt.title(names[i])
plt.axis('scaled')
levels = giplt.contourf(xp * 0.001, yp * 0.001, data, (100, 100), 12)
plt.colorbar()
giplt.contour(xp * 0.001, yp * 0.001, data, shape, levels, clabel=False)
plt.show()
from geoist.inversion import geometry
from geoist.pfm import prism
from geoist.vis import giplt
model = [
geometry.Prism(-4000, -3000, -4000, -3000, 0, 2000, {'density': 1000}),
geometry.Prism(-1000, 1000, -1000, 1000, 0, 2000, {'density': -900}),
geometry.Prism(2000, 4000, 3000, 4000, 0, 2000, {'density': 1300})
]
shape = (100, 100)
xp, yp, zp = gridder.regular((-5000, 5000, -5000, 5000), shape, z=-150)
field0 = prism.potential(xp, yp, zp, model)
from geoist.pfm import giutils
field0 = giutils.contaminate(field0, 0.05, percent=True)
fields = [
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'
]
area = (0, 2, 0, 2)
shape = (10, 10)
model = SquareMesh(area, shape)
vp = 4*np.ones(shape)
vp[3:7,3:7] = 10
print(vp)
model.addprop('vp', vp.ravel())
src_loc_x, src_loc_y = scatter(area, 30, seed=0)
src_loc = np.transpose([src_loc_x, src_loc_y])
rec_loc_x, rec_loc_y = circular_scatter(area, 20, random=True, seed=0)
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 = giutils.contaminate(tts, 0.01, percent=True, seed=0)
# Now we can setup a tomography by creating the necessary data misfit
# (``SRTomo``) and regularization (``Smoothness2D``) objects. We'll normalize
# the data misfit by the number of data points to make the scale of the
# regularization parameter more tractable.
mesh = SquareMesh(area, shape)
datamisfit = (1./tts.size)*SRTomo(tts, srcs, recs, mesh)
regul = Smoothness2D(mesh.shape)
# The tomography solver will be the ``LCurve`` solver. It works by calling
# ``fit()`` and accessing ``estimate_``, exactly like any other solver:
regul_params = [10**i for i in range(-10, -2, 1)]
tomo = LCurve(datamisfit, regul, regul_params)
# Make a velocity model to calculate traveltimes
area = (0, 10, 0, 10)
vp, vs = 2, 1
model = [Square(area, props={'vp': vp, 'vs': vs})]
src = (5, 5)
srcs = [src, src, src, src]
recs = [(1, 2), (3, 6), (4, 7), (2, 8)]
#giutils.connect_points(src, rec_points)
ptime = ttime2d.straight(model, 'vp', srcs, recs)
stime = ttime2d.straight(model, 'vs', srcs, recs)
# Calculate the residual time (S - P) with added noise
traveltime, error = giutils.contaminate(stime - ptime,
0.05,
percent=True,
return_stddev=True)
solver = Homogeneous(traveltime, recs, vp, vs)
initial = (1, 1)
estimate = solver.config('levmarq', initial=initial).fit().estimate_
plt.figure(figsize=(10, 4))
plt.subplot(1, 2, 1)
plt.title('Epicenter + %d recording stations' % (len(recs)))
plt.axis('scaled')
giplt.points(src, '*y', label="True")
giplt.points(recs, '^r', label="Stations")
giplt.points(initial, '*b', label="Initial")
giplt.points([estimate], '*g', label="Estimate")
giplt.set_area(area)
"""
GravMag: Calculate the analytic signal of a total field anomaly using FFT
"""
import matplotlib.pyplot as plt
from geoist import gridder
from geoist.inversion import geometry
from geoist.pfm import prism, pftrans, giutils
from geoist.vis import giplt
model = [geometry.Prism(-100, 100, -100, 100, 0, 2000, {'magnetization': 10})]
area = (-5000, 5000, -5000, 5000)
shape = (100, 100)
z0 = -500
x, y, z = gridder.regular(area, shape, z=z0)
inc, dec = -30, 0
tf = giutils.contaminate(prism.tf(x, y, z, model, inc, dec), 0.001,
percent=True)
# Need to convert gz to SI units so that the result is also in SI
total_grad_amp = pftrans.tga(x, y, giutils.nt2si(tf), shape)
plt.figure()
plt.subplot(1, 2, 1)
plt.title("Original total field anomaly")
plt.axis('scaled')
giplt.contourf(y, x, tf, shape, 30, cmap=plt.cm.RdBu_r)
plt.colorbar(orientation='horizontal').set_label('nT')
giplt.m2km()
plt.subplot(1, 2, 2)
plt.title("Total Gradient Amplitude")
plt.axis('scaled')
giplt.contourf(y, x, total_grad_amp, shape, 30, cmap=plt.cm.RdBu_r)
from geoist.pfm.giutils import ang2vec, contaminate
from geoist.pfm import sphere
from geoist.pfm.magdir import DipoleMagDir
from geoist.vis import giplt
# Make noise-corrupted synthetic data
inc, dec = -10.0, -15.0 # inclination and declination of the Geomagnetic Field
model = [
geometry.Sphere(3000, 3000, 1000, 1000,
{'magnetization': ang2vec(6.0, -20.0, -10.0)}),
geometry.Sphere(7000, 7000, 1000, 1000,
{'magnetization': ang2vec(10.0, 3.0, -67.0)})
]
area = (0, 10000, 0, 10000)
x, y, z = gridder.scatter(area, 1000, z=-150, seed=0)
tf = contaminate(sphere.tf(x, y, z, model, inc, dec), 5.0, seed=0)
# Give the centers of the dipoles
centers = [[3000, 3000, 1000], [7000, 7000, 1000]]
# Estimate the magnetization vectors
solver = DipoleMagDir(x, y, z, tf, inc, dec, centers).fit()
# Print the estimated and true dipole monents, inclinations and declinations
print('Estimated magnetization (intensity, inclination, declination)')
for e in solver.estimate_:
print(e)
# Plot the fit and the normalized histogram of the residuals
plt.figure(figsize=(14, 5))
plt.subplot(1, 2, 1)
