def setUp(self):
# Define inducing field and sphere parameters
H0 = (50000.0, 60.0, 250.0)
# H0 = (50000., 90., 0.)
self.b0 = mag.analytics.IDTtoxyz(-H0[1], H0[2], H0[0])
self.rad = 2.0
self.chi = 0.01
# Define a mesh
cs = 0.2
hxind = [(cs, 21)]
hyind = [(cs, 21)]
hzind = [(cs, 21)]
mesh = discretize.TensorMesh([hxind, hyind, hzind], "CCC")
# Get cells inside the sphere
sph_ind = getIndicesSphere([0.0, 0.0, 0.0], self.rad, mesh.gridCC)
# Adjust susceptibility for volume difference
Vratio = (4.0 / 3.0 * np.pi * self.rad**3.0) / (np.sum(sph_ind) *
cs**3.0)
model = np.ones(mesh.nC) * self.chi * Vratio
self.model = model[sph_ind]
# Creat reduced identity map for Linear Pproblem
idenMap = maps.IdentityMap(nP=int(sum(sph_ind)))
# Create plane of observations
xr = np.linspace(-20, 20, nx)
yr = np.linspace(-20, 20, ny)
self.xr = xr
self.yr = yr
X, Y = np.meshgrid(xr, yr)
components = ["bx", "by", "bz", "tmi"]
# Move obs plane 2 radius away from sphere
Z = np.ones((xr.size, yr.size)) * 2.0 * self.rad
self.locXyz = np.c_[utils.mkvc(X), utils.mkvc(Y), utils.mkvc(Z)]
rxLoc = mag.Point(self.locXyz, components=components)
srcField = mag.SourceField([rxLoc], parameters=H0)
self.survey = mag.Survey(srcField)
self.sim = mag.Simulation3DIntegral(
mesh,
survey=self.survey,
chiMap=idenMap,
actInd=sph_ind,
store_sensitivities="forward_only",
)
def setUp(self):
# Define sphere parameters
self.rad = 2.0
self.rho = 0.1
# Define a mesh
cs = 0.2
hxind = [(cs, 21)]
hyind = [(cs, 21)]
hzind = [(cs, 21)]
mesh = discretize.TensorMesh([hxind, hyind, hzind], "CCC")
# Get cells inside the sphere
sph_ind = getIndicesSphere([0.0, 0.0, 0.0], self.rad, mesh.gridCC)
# Adjust density for volume difference
Vratio = (4.0 / 3.0 * np.pi * self.rad**3.0) / (np.sum(sph_ind) *
cs**3.0)
model = np.ones(mesh.nC) * self.rho * Vratio
self.model = model[sph_ind]
# Create reduced identity map for Linear Pproblem
idenMap = maps.IdentityMap(nP=int(sum(sph_ind)))
# Create plane of observations
xr = np.linspace(-20, 20, nx)
yr = np.linspace(-20, 20, ny)
X, Y = np.meshgrid(xr, yr)
self.xr = xr
self.yr = yr
components = ["gx", "gy", "gz"]
# Move obs plane 2 radius away from sphere
Z = np.ones((xr.size, yr.size)) * 2.0 * self.rad
self.locXyz = np.c_[utils.mkvc(X), utils.mkvc(Y), utils.mkvc(Z)]
receivers = gravity.Point(self.locXyz, components=components)
sources = gravity.SourceField([receivers])
self.survey = gravity.Survey(sources)
self.sim = gravity.Simulation3DIntegral(
mesh,
survey=self.survey,
rhoMap=idenMap,
actInd=sph_ind,
store_sensitivities="disk",
)
def setUp(self):
Inc = 45.0
Dec = 45.0
Btot = 51000
H0 = (Btot, Inc, Dec)
self.b0 = mag.analytics.IDTtoxyz(-Inc, Dec, Btot)
cs = 25.0
hxind = [(cs, 5, -1.3), (cs / 2.0, 41), (cs, 5, 1.3)]
hyind = [(cs, 5, -1.3), (cs / 2.0, 41), (cs, 5, 1.3)]
hzind = [(cs, 5, -1.3), (cs / 2.0, 40), (cs, 5, 1.3)]
M = discretize.TensorMesh([hxind, hyind, hzind], "CCC")
chibkg = 0.0
self.chiblk = 0.01
chi = np.ones(M.nC) * chibkg
self.rad = 100
self.sphere_center = [0.0, 0.0, 0.0]
sph_ind = getIndicesSphere(self.sphere_center, self.rad, M.gridCC)
chi[sph_ind] = self.chiblk
xr = np.linspace(-300, 300, 41)
yr = np.linspace(-300, 300, 41)
X, Y = np.meshgrid(xr, yr)
Z = np.ones((xr.size, yr.size)) * 150
components = ["bx", "by", "bz"]
self.xr = xr
self.yr = yr
self.rxLoc = np.c_[utils.mkvc(X), utils.mkvc(Y), utils.mkvc(Z)]
receivers = mag.Point(self.rxLoc, components=components)
srcField = mag.SourceField([receivers], parameters=H0)
self.survey = mag.Survey(srcField)
self.sim = mag.simulation.Simulation3DDifferential(
M,
survey=self.survey,
muMap=maps.ChiMap(M),
solver=Pardiso,
)
self.M = M
self.chi = chi
directiveList=directives_list)
# Run inversion
recovered_conductivity_model = dc_inversion.run(starting_conductivity_model)
###############################################################
# Recreate True Conductivity Model
# --------------------------------
#
background_value = 1e-2
conductor_value = 1e-1
resistor_value = 1e-3
true_conductivity_model = background_value * np.ones(nC)
ind_conductor = model_builder.getIndicesSphere(
np.r_[-350.0, 0.0, -300.0], 160.0, mesh.cell_centers[ind_active, :])
true_conductivity_model[ind_conductor] = conductor_value
ind_resistor = model_builder.getIndicesSphere(np.r_[350.0, 0.0, -300.0], 160.0,
mesh.cell_centers[ind_active, :])
true_conductivity_model[ind_resistor] = resistor_value
true_conductivity_model_log10 = np.log10(true_conductivity_model)
###############################################################
# Plotting True and Recovered Conductivity Model
# ----------------------------------------------
#
# Plot True Model
fig = plt.figure(figsize=(10, 4))
# Define model. Models in SimPEG are vector arrays.
true_model = background_density * np.ones(nC)
# You could find the indicies of specific cells within the model and change their
# value to add structures.
ind_block = ((mesh.gridCC[ind_active, 0] > -50.0)
& (mesh.gridCC[ind_active, 0] < -20.0)
& (mesh.gridCC[ind_active, 1] > -15.0)
& (mesh.gridCC[ind_active, 1] < 15.0)
& (mesh.gridCC[ind_active, 2] > -50.0)
& (mesh.gridCC[ind_active, 2] < -30.0))
true_model[ind_block] = block_density
# You can also use SimPEG utilities to add structures to the model more concisely
ind_sphere = model_builder.getIndicesSphere(np.r_[35.0, 0.0, -40.0], 15.0,
mesh.gridCC)
ind_sphere = ind_sphere[ind_active]
true_model[ind_sphere] = sphere_density
############################################################
# Plotting True Model and Recovered Model
# ---------------------------------------
#
# Plot True Model
fig = plt.figure(figsize=(9, 4))
plotting_map = maps.InjectActiveCells(mesh, ind_active, np.nan)
ax1 = fig.add_axes([0.1, 0.1, 0.73, 0.8])
mesh.plotSlice(
plotting_map * true_model,
# Run inversion
recovered_conductivity_model = dc_inversion.run(starting_conductivity_model)
############################################################
# Plotting True and Recovered Conductivity Model
# ----------------------------------------------
#
# Recreate true conductivity model
true_background_conductivity = 1e-2
true_conductor_conductivity = 1e-1
true_resistor_conductivity = 1e-3
true_conductivity_model = true_background_conductivity * np.ones(len(mesh))
ind_conductor = model_builder.getIndicesSphere(np.r_[-120.0, -180.0], 60.0,
mesh.gridCC)
true_conductivity_model[ind_conductor] = true_conductor_conductivity
ind_resistor = model_builder.getIndicesSphere(np.r_[120.0, -180.0], 60.0,
mesh.gridCC)
true_conductivity_model[ind_resistor] = true_resistor_conductivity
true_conductivity_model[~ind_active] = np.NaN
# Plot True Model
norm = LogNorm(vmin=1e-3, vmax=1e-1)
fig = plt.figure(figsize=(9, 4))
ax1 = fig.add_axes([0.1, 0.12, 0.72, 0.8])
im = mesh.plot_image(
true_conductivity_model,
# Print target misfit to compare with convergence
# print("Target misfit is " + str(target_misfit.target))
# Run the inversion
recovered_model = inv.run(starting_model)
##############################################################
# Recreate True Model
# -------------------
#
background_susceptibility = 0.0001
sphere_susceptibility = 0.01
true_model = background_susceptibility * np.ones(nC)
ind_sphere = model_builder.getIndicesSphere(np.r_[0.0, 0.0, -45.0], 15.0,
mesh.cell_centers)
ind_sphere = ind_sphere[ind_active]
true_model[ind_sphere] = sphere_susceptibility
############################################################
# Plotting True Model and Recovered Model
# ---------------------------------------
#
# Plot True Model
fig = plt.figure(figsize=(9, 4))
plotting_map = maps.InjectActiveCells(mesh, ind_active, np.nan)
ax1 = fig.add_axes([0.08, 0.1, 0.75, 0.8])
mesh.plotSlice(
plotting_map * true_model,
# Define surface topography
[xx, yy] = np.meshgrid(mesh.vectorNx, mesh.vectorNy)
zz = -3 * np.exp((xx**2 + yy**2) / 60**2) + 45.0
topo = np.c_[mkvc(xx), mkvc(yy), mkvc(zz)]
# Set active cells and define unit values
air_value = 0.0
ind_active = surface2ind_topo(mesh, topo)
model_map = maps.InjectActiveCells(mesh, ind_active, air_value)
# Define model for cells under the surface topography
model = background_value * np.ones(ind_active.sum())
# Add a sphere
ind_sphere = model_builder.getIndicesSphere(np.r_[-25.0, 0.0, -15.0], 20.0,
mesh.gridCC)
ind_sphere = ind_sphere[ind_active] # So same size and order as model
model[ind_sphere] = sphere_value
# Add dyke defined by a set of points
xp = np.kron(np.ones((2)), [-10.0, 10.0, 55.0, 35.0])
yp = np.kron([-1000.0, 1000.0], np.ones((4)))
zp = np.kron(np.ones((2)), [-120.0, -120.0, 45.0, 45.0])
xyz_pts = np.c_[mkvc(xp), mkvc(yp), mkvc(zp)]
ind_polygon = model_builder.PolygonInd(mesh, xyz_pts)
ind_polygon = ind_polygon[ind_active] # So same size and order as model
model[ind_polygon] = dyke_value
# Plot
fig = plt.figure(figsize=(5, 5))
ax = fig.add_subplot(111)
def test_ana_boundary_computation(self):
hxind = [(0, 25, 1.3), (21, 12.5), (0, 25, 1.3)]
hyind = [(0, 25, 1.3), (21, 12.5), (0, 25, 1.3)]
hzind = [(0, 25, 1.3), (20, 12.5), (0, 25, 1.3)]
# hx, hy, hz = Utils.meshTensors(hxind, hyind, hzind)
M3 = discretize.TensorMesh([hxind, hyind, hzind], "CCC")
indxd, indxu, indyd, indyu, indzd, indzu = M3.faceBoundaryInd
mu0 = 4 * np.pi * 1e-7
chibkg = 0.0
chiblk = 0.01
chi = np.ones(M3.nC) * chibkg
sph_ind = getIndicesSphere([0, 0, 0], 100, M3.gridCC)
chi[sph_ind] = chiblk
mu = (1.0 + chi) * mu0
Bbc, const = mag.analytics.CongruousMagBC(M3, np.array([1.0, 0.0,
0.0]), chi)
flag = "secondary"
Box = 1.0
H0 = Box / mu_0
Bbcxx, Bbcxy, Bbcxz = mag.analytics.MagSphereAnaFun(
M3.gridFx[(indxd | indxu), 0],
M3.gridFx[(indxd | indxu), 1],
M3.gridFx[(indxd | indxu), 2],
100,
0.0,
0.0,
0.0,
mu_0,
mu_0 * (1 + chiblk),
H0,
flag,
)
Bbcyx, Bbcyy, Bbcyz = mag.analytics.MagSphereAnaFun(
M3.gridFy[(indyd | indyu), 0],
M3.gridFy[(indyd | indyu), 1],
M3.gridFy[(indyd | indyu), 2],
100,
0.0,
0.0,
0.0,
mu_0,
mu_0 * (1 + chiblk),
H0,
flag,
)
Bbczx, Bbczy, Bbczz = mag.analytics.MagSphereAnaFun(
M3.gridFz[(indzd | indzu), 0],
M3.gridFz[(indzd | indzu), 1],
M3.gridFz[(indzd | indzu), 2],
100,
0.0,
0.0,
0.0,
mu_0,
mu_0 * (1 + chiblk),
H0,
flag,
)
Bbc_ana = np.r_[Bbcxx, Bbcyy, Bbczz]
if plotIt:
import matplotlib.pyplot as plt
fig, ax = plt.subplots(1, 1, figsize=(10, 10))
ax.plot(Bbc_ana)
ax.plot(Bbc)
plt.show()
err = np.linalg.norm(Bbc - Bbc_ana) / np.linalg.norm(Bbc_ana)
assert err < 0.1, "Mag Boundary computation is wrong!!, err = {}".format(
err)
