def gen_obs_grid(self,height=0):
if self.obs_area is None:
self.obs_area = (self.source_volume[0]+0.5*self.mesh.dims[0],
self.source_volume[1]-0.5*self.mesh.dims[0],
self.source_volume[2]+0.5*self.mesh.dims[1],
self.source_volume[3]-0.5*self.mesh.dims[1])
obs_shape = (self.nobsx, self.nobsy)
self.xp, self.yp, self.zp = gridder.regular(self.obs_area, obs_shape, z=height)
def gen_obs_grid(self,height=-1):
""" generate obs grid
"""
obs_area = (self.source_volume[0]+0.5*self.mesh.dims[0],
self.source_volume[1]-0.5*self.mesh.dims[0],
self.source_volume[2]+0.5*self.mesh.dims[1],
self.source_volume[3]-0.5*self.mesh.dims[1])
obs_shape = (self.nx, self.ny)
return gridder.regular(obs_area, obs_shape, z=height)
def gen_mesh(self,height = -1):
shape = (self._nz, self._ny, self._nx)
self.mesh = PrismMesh(self._source_volume, shape)
density = np.ones(shape)*1.0e3
self.mesh.addprop('density', density.ravel())
# generate obs grid
# coordinate: x North-South,y East-West
# gridder is in the order: (nx,ny)
self.obs_area = (self._source_volume[0]+0.5*self.mesh.dims[0],
self._source_volume[1]-0.5*self.mesh.dims[0],
self._source_volume[2]+0.5*self.mesh.dims[1],
self._source_volume[3]-0.5*self.mesh.dims[1])
obs_shape = (self.nobsx, self.nobsy)
self.xp, self.yp, self.zp = gridder.regular(self.obs_area, obs_shape, z=height)
def gen_grav(shape = (100, 100)):
dx = 6000/8.
dy = 6000/8.
dz = 1900/8.
model = [geometry.Prism(-1000, 1000, -1000, 1000, 100, 2000, {'density': 1000}),
geometry.Prism(-4000, -3000, -4000, -3000, 100, 2000, {'density': -900}),
geometry.Prism(2000, 4000, 3000, 4000, 100, 2000, {'density': 1300})]
prism1 = geometry.Prism(-3000+3*dx, -3000+4*dx, -3000+7*dy, -3000+8*dy, 100+4*dz, 100+5*dz, {'density': 2000})
prism2 = geometry.Prism(-3000+2*dx, -3000+3*dx, -3000+2*dy, -3000+3*dy, 100+4*dz, 100+5*dz, {'density': 2000})
model = [prism1,prism2]
nzyx = [8,8,8]
source_volume = [-3000, 3000, -3000, 3000, 100, 2000]
xp, yp, zp = gridder.regular((-5000, 5000, -5000, 5000), shape, z=0)
field0 = prism.gz(xp, yp, zp, model)
fieldfreq = pftrans.gzfreq(xp, yp, zp, shape, model)
#field1 = giutils.contaminate(field0, 0.05, percent = True)
return field0, fieldfreq, xp, yp, zp
def gen_grav(shape=(100, 100)):
model = [
geometry.Prism(-1000, 1000, -1000, 1000, 100, 2000, {'density': 1000}),
geometry.Prism(-4000, -3000, -4000, -3000, 100, 2000,
{'density': -900}),
geometry.Prism(2000, 4000, 3000, 4000, 100, 2000, {'density': 1300})
]
xp, yp, zp = gridder.regular((-5000, 5000, -5000, 5000), shape, z=0)
field0 = prism.gz(xp, yp, zp, model)
#prism.potential(xp, yp, zp, model)
#field1 = giutils.contaminate(field0, 0.05, percent = True)
fieldfreq = gzfreq(xp, yp, zp, shape, model)
# 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)]
return field0, fieldfreq, xp, yp, zp
radius=1.5e3,
props={'magnetization': giutils.ang2vec(1, inc=50, dec=-30)}),
geometry.Sphere(
x=20e3,
y=20e3,
z=2e3,
radius=1.5e3,
props={'magnetization': giutils.ang2vec(1, inc=-70, dec=30)})
]
# Set the inclination and declination of the geomagnetic field.
inc, dec = -10, 13
# Create a regular grid at a constant height
shape = (300, 300)
area = [0, 30e3, 0, 30e3]
x, y, z = gridder.regular(area, shape, z=-10)
fields = [
['Total field Anomaly (nt)',
sphere.tf(x, y, z, model, inc, dec)],
['Bx (nT)', sphere.bx(x, y, z, model)],
['By (nT)', sphere.by(x, y, z, model)],
['Bz (nT)', sphere.bz(x, y, z, model)],
]
# Make maps of all fields calculated
fig = plt.figure(figsize=(7, 6))
plt.rcParams['font.size'] = 10
X, Y = x.reshape(shape) / 1000, y.reshape(shape) / 1000
for i, tmp in enumerate(fields):
ax = plt.subplot(2, 2, i + 1)
"""
Meshing: Generate a 3D prism model of the topography
"""
from geoist import gridder
from geoist.pfm import giutils
from geoist.inversion import mesh
area = (-150, 150, -300, 300)
shape = (100, 50)
x, y = gridder.regular(area, shape)
height = (
-80 * giutils.gaussian2d(x, y, 100, 200, x0=-50, y0=-100, angle=-60) +
100 * giutils.gaussian2d(x, y, 50, 100, x0=80, y0=170))
nodes = (x, y, -1 * height) # -1 is to convert height to z coordinate
reference = 0 # z coordinate of the reference surface
relief = mesh.PrismRelief(reference, shape, nodes)
relief.addprop('density', (2670 for i in range(relief.size)))
prop = 'density'
for prism in relief:
if prism is None or (prop is not None and prop not in prism.props):
continue
x1, x2, y1, y2, z1, z2 = prism.get_bounds()
# Tesseroid
w, e = -2, 2
s, n = -2, 2
bounds = (w, e, s, n, 500000, 0)
x, y = gridder.regular((w, e, s, n), (50, 50))
graoutfile = r"d:\gra3.dat"
magoutfile = r"d:\mag3.dat"
graoutfile1 = r"d:\gra3n.dat"
magoutfile1 = r"d:\mag3n.dat"
area = (-200, 200, -600, 600, 0, 600) #x y z
shape = (100, 150, 1) # z y x
mesh = PrismMesh(area, shape)
mesh.addprop('density', 1000.*rho1.ravel()-2650.0001)
mesh.addprop('magnetization', mag1.ravel())
mesh.dump(meshfile, densfile, 'density') #输出网格到磁盘，MeshTools3D可视化
mesh.dump(meshfile, magfile, 'magnetization')
#生成核矩阵
kernel=[]
narea = (-500, 500,-1000, 1000) #y x
nshape = (20, 40)
xp, yp, zp = gridder.regular(narea, nshape, z=-1)
prisms=[]
for p in mesh:
prisms.append(p)
print('kernel')
inc, dec = 30, -4
kernelgz = prism.gz_kernel(xp, yp, zp, prisms)
for i, layer in enumerate(mesh.layers()):
for j, p in enumerate(layer):
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
# The regional field
inc, dec = 30, -15
bounds = [-5000, 5000, -5000, 5000, 0, 5000]
model = [
geometry.Prism(-4000, -3000, -4000, -3000, 0, 2000,
{'magnetization': giutils.ang2vec(1, inc, dec)}),
geometry.Prism(-1000, 1000, -1000, 1000, 0, 2000,
{'magnetization': giutils.ang2vec(1, inc, dec)}),
# This prism will have magnetization in a different direction
geometry.Prism(2000, 4000, 3000, 4000, 0, 2000,
{'magnetization': giutils.ang2vec(3, -10, 45)})
]
# Create a regular grid at 100m height
shape = (200, 200)
area = bounds[:4]
xp, yp, zp = gridder.regular(area, shape, z=-500)
# Calculate the anomaly for a given regional field
tf = prism.tf(xp, yp, zp, model, inc, dec)
# Plot
plt.figure()
plt.title("Total-field anomaly (nT)")
plt.axis('scaled')
giplt.contourf(yp, xp, tf, shape, 15)
plt.colorbar()
plt.xlabel('East y (km)')
plt.ylabel('North x (km)')
giplt.m2km()
plt.show()
"""
# 3rd imports
import matplotlib.pyplot as plt
# local imports
from geoist import gridder
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)
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'
]
meshfile = r"d:\msh.txt" #StringIO()
densfile = r"d:\den.txt" #StringIO()
mesh = PrismMesh((0, 10, 0, 20, 0, 5), (5, 2, 2))
mesh.addprop('density', 1000.0 * np.random.rand(20))
mesh.dump(meshfile, densfile, 'density')
#print(meshfile.getvalue().strip())
#print(densfile.getvalue().strip())
model = []
for i, layer in enumerate(mesh.layers()):
for j, p in enumerate(layer):
#print(i,j, p)
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.append(geometry.Prism(x1, x2, y1, y2, z1, z2, den))
#model.append(geometry.Prism(x1, x2, y1, y2, z1, z2, {'density': 1000}))
xp, yp, zp = gridder.regular((-5, 15, -5, 25), (20, 20), z=-1)
field = prism.gz(xp, yp, zp, model)
plt.figure(figsize=(8, 9))
plt.axis('scaled')
plt.title('forward gravity anomaly')
levels = giplt.contourf(yp, xp, field, (20, 20), 15)
cb = plt.colorbar()
giplt.contour(yp, xp, field, (20, 20), levels, clabel=False, linewidth=0.1)
plt.show()
import matplotlib.pyplot as plt
import numpy as np
from geoist import gridder
from geoist.inversion import geometry
from geoist.pfm import prism
from geoist.inversion.mesh import PrismMesh
from geoist.vis import giplt
meshfile = r"d:\msh.txt"
densfile = r"d:\den.txt"
#生成场源网格 10km*20km*5km, 500个单元，z方向5层
mesh = PrismMesh((0, 10000, 0, 20000, 0, 5000), (20, 20, 20))
mesh.addprop('density', 1000.0 * np.random.rand(8000))
mesh.dump(meshfile, densfile, 'density') #输出网格到磁盘，MeshTools3D可视化
#生成核矩阵
kernel = []
xp, yp, zp = gridder.regular((-5000, 15000, -5000, 25000), (20, 20), z=-1)
for i, layer in enumerate(mesh.layers()):
for j, p in enumerate(layer):
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)
kk = np.array(kernel)
kk = np.transpose(kk) #kernel matrix for inversion, 500 cells * 400 points
from mpl_toolkits.basemap import Basemap
# local imports
from geoist import gridder
from geoist.inversion.geometry import Tesseroid
from geoist.pfm import polyprism, giutils, tesseroid
from geoist.vis import giplt
model = [
Tesseroid(-60, -55, -30, -27, 0, -500000, props={'density': 200}),
Tesseroid(-66, -62, -18, -12, 0, -300000, props={'density': -500})
]
# Create the computation grid
area = (-80, -30, -40, 10)
shape = (100, 100)
lons, lats, heights = gridder.regular(area, shape, z=250000)
start = time.time()
fields = [
tesseroid.potential(lons, lats, heights, model),
tesseroid.gx(lons, lats, heights, model),
tesseroid.gy(lons, lats, heights, model),
tesseroid.gz(lons, lats, heights, model),
tesseroid.gxx(lons, lats, heights, model),
tesseroid.gxy(lons, lats, heights, model),
tesseroid.gxz(lons, lats, heights, model),
tesseroid.gyy(lons, lats, heights, model),
tesseroid.gyz(lons, lats, heights, model),
tesseroid.gzz(lons, lats, heights, model)
]
print("Time it took: %s" % (time.time() - start))
