def setUp(self):
ntx = 31
xtemp_txP = np.logspace(1, 3, ntx)
xtemp_txN = -xtemp_txP
ytemp_tx = np.zeros(ntx)
xtemp_rxP = -5
xtemp_rxN = 5
ytemp_rx = 0.0
abhalf = abs(xtemp_txP - xtemp_txN) * 0.5
a = xtemp_rxN - xtemp_rxP
b = ((xtemp_txN - xtemp_txP) - a) * 0.5
# We generate tx and rx lists:
srclist = []
for i in range(ntx):
rx = dc.receivers.Dipole(np.r_[xtemp_rxP, ytemp_rx, -12.5],
np.r_[xtemp_rxN, ytemp_rx, -12.5])
locA = np.r_[xtemp_txP[i], ytemp_tx[i], -12.5]
locB = np.r_[xtemp_txN[i], ytemp_tx[i], -12.5]
src = dc.sources.Dipole([rx], locA, locB)
srclist.append(src)
survey = dc.survey.Survey(srclist)
rho = np.r_[10, 10, 10]
dummy_hz = 100.0
hz = np.r_[10, 10, dummy_hz]
mesh = TensorMesh([hz])
simulation = dc.simulation_1d.Simulation1DLayers(
survey=survey,
rhoMap=maps.ExpMap(mesh),
thicknesses=hz[:-1],
data_type="apparent_resistivity",
)
simulation.dpred(np.log(rho))
mSynth = np.log(rho)
dobs = simulation.make_synthetic_data(mSynth, add_noise=True)
# Now set up the problem to do some minimization
dmis = data_misfit.L2DataMisfit(simulation=simulation, data=dobs)
reg = regularization.Tikhonov(mesh)
opt = optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=0.0)
inv = inversion.BaseInversion(invProb)
self.inv = inv
self.reg = reg
self.p = simulation
self.mesh = mesh
self.m0 = mSynth
self.survey = survey
self.dmis = dmis
self.dobs = dobs
def run_inversion(
m0,
simulation,
data,
actind,
mesh,
maxIter=15,
beta0_ratio=1e0,
coolingFactor=5,
coolingRate=2,
upper=np.inf,
lower=-np.inf,
use_sensitivity_weight=True,
alpha_s=1e-4,
alpha_x=1.0,
alpha_y=1.0,
alpha_z=1.0,
):
"""
Run DC inversion
"""
dmisfit = data_misfit.L2DataMisfit(simulation=simulation, data=data)
# Map for a regularization
regmap = maps.IdentityMap(nP=int(actind.sum()))
# Related to inversion
if use_sensitivity_weight:
reg = regularization.Sparse(mesh, indActive=actind, mapping=regmap)
reg.alpha_s = alpha_s
reg.alpha_x = alpha_x
reg.alpha_y = alpha_y
reg.alpha_z = alpha_z
else:
reg = regularization.Tikhonov(mesh, indActive=actind, mapping=regmap)
reg.alpha_s = alpha_s
reg.alpha_x = alpha_x
reg.alpha_y = alpha_y
reg.alpha_z = alpha_z
opt = optimization.ProjectedGNCG(maxIter=maxIter, upper=upper, lower=lower)
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
beta = directives.BetaSchedule(coolingFactor=coolingFactor,
coolingRate=coolingRate)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=beta0_ratio)
target = directives.TargetMisfit()
# Need to have basice saving function
update_Jacobi = directives.UpdatePreconditioner()
if use_sensitivity_weight:
updateSensW = directives.UpdateSensitivityWeights()
directiveList = [beta, target, updateSensW, update_Jacobi, betaest]
else:
directiveList = [beta, target, update_Jacobi, betaest]
inv = inversion.BaseInversion(invProb, directiveList=directiveList)
opt.LSshorten = 0.5
opt.remember("xc")
# Run inversion
mopt = inv.run(m0)
return mopt, invProb.dpred
def test_inv(self):
reg = regularization.Tikhonov(self.mesh)
opt = optimization.InexactGaussNewton(maxIter=10)
invProb = inverse_problem.BaseInvProblem(self.dmiscobmo, reg, opt)
directives_list = [directives.BetaEstimate_ByEig(beta0_ratio=1e-2)]
print(len(directives_list))
inv = inversion.BaseInversion(invProb, directiveList=directives_list)
m0 = self.model.mean() * np.ones_like(self.model)
mrec = inv.run(m0)
def setUp(self):
cs = 12.5
hx = [(cs, 7, -1.3), (cs, 61), (cs, 7, 1.3)]
hy = [(cs, 7, -1.3), (cs, 20)]
mesh = discretize.TensorMesh([hx, hy], x0="CN")
# x = np.linspace(-200, 200., 20)
x = np.linspace(-200, 200.0, 2)
M = utils.ndgrid(x - 12.5, np.r_[0.0])
N = utils.ndgrid(x + 12.5, np.r_[0.0])
A0loc = np.r_[-150, 0.0]
A1loc = np.r_[-130, 0.0]
B0loc = np.r_[-130, 0.0]
B1loc = np.r_[-110, 0.0]
rx = dc.Rx.Dipole(M, N)
src0 = dc.Src.Dipole([rx], A0loc, B0loc)
src1 = dc.Src.Dipole([rx], A1loc, B1loc)
survey = ip.Survey([src0, src1])
sigma = np.ones(mesh.nC) * 1.0
problem = ip.Simulation2DCellCentered(
mesh,
survey=survey,
sigma=sigma,
etaMap=maps.IdentityMap(mesh),
verbose=False,
)
mSynth = np.ones(mesh.nC) * 0.1
dobs = problem.make_synthetic_data(mSynth, add_noise=True)
# Now set up the problem to do some minimization
dmis = data_misfit.L2DataMisfit(data=dobs, simulation=problem)
reg = regularization.Tikhonov(mesh)
opt = optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=1e4)
inv = inversion.BaseInversion(invProb)
self.inv = inv
self.reg = reg
self.p = problem
self.mesh = mesh
self.m0 = mSynth
self.survey = survey
self.dmis = dmis
def test_inv(self):
reg = regularization.Tikhonov(self.mesh)
opt = optimization.InexactGaussNewton(maxIter=10, use_WolfeCurvature=True)
invProb = inverse_problem.BaseInvProblem(self.dmiscombo, reg, opt)
directives_list = [
directives.ScalingMultipleDataMisfits_ByEig(verbose=True),
directives.AlphasSmoothEstimate_ByEig(verbose=True),
directives.BetaEstimate_ByEig(beta0_ratio=1e-2),
directives.BetaSchedule(),
]
inv = inversion.BaseInversion(invProb, directiveList=directives_list)
m0 = self.model.mean() * np.ones_like(self.model)
mrec = inv.run(m0)
def setUp(self):
aSpacing = 2.5
nElecs = 10
surveySize = nElecs * aSpacing - aSpacing
cs = surveySize / nElecs / 4
mesh = discretize.TensorMesh(
[
[(cs, 10, -1.3), (cs, surveySize / cs), (cs, 10, 1.3)],
[(cs, 3, -1.3), (cs, 3, 1.3)],
# [(cs, 5, -1.3), (cs, 10)]
],
"CN",
)
source_list = dc.utils.WennerSrcList(nElecs, aSpacing, in2D=True)
survey = dc.survey.Survey(source_list)
simulation = dc.simulation.Simulation3DNodal(
mesh=mesh,
survey=survey,
rhoMap=maps.IdentityMap(mesh),
storeJ=True,
bc_type="Robin",
)
mSynth = np.ones(mesh.nC)
dobs = simulation.make_synthetic_data(mSynth, add_noise=True)
# Now set up the problem to do some minimization
dmis = data_misfit.L2DataMisfit(simulation=simulation, data=dobs)
reg = regularization.Tikhonov(mesh)
opt = optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=1e4)
inv = inversion.BaseInversion(invProb)
self.inv = inv
self.reg = reg
self.p = simulation
self.mesh = mesh
self.m0 = mSynth
self.survey = survey
self.dmis = dmis
self.dobs = dobs
def test_inv_mref_setting(self):
reg1 = regularization.Tikhonov(self.mesh)
reg2 = regularization.Tikhonov(self.mesh)
reg = reg1 + reg2
opt = optimization.InexactGaussNewton(maxIter=10)
invProb = inverse_problem.BaseInvProblem(self.dmiscobmo, reg, opt)
directives_list = [directives.BetaEstimate_ByEig(beta0_ratio=1e-2)]
inv = inversion.BaseInversion(invProb, directiveList=directives_list)
m0 = self.model.mean() * np.ones_like(self.model)
mrec = inv.run(m0)
self.assertTrue(np.all(reg1.mref == m0))
self.assertTrue(np.all(reg2.mref == m0))
def setUp(self):
print("\n ---- Testing {} ---- \n".format(self.formulation))
cs = 12.5
hx = [(cs, 2, -1.3), (cs, 61), (cs, 2, 1.3)]
hy = [(cs, 2, -1.3), (cs, 20)]
mesh = discretize.TensorMesh([hx, hy], x0="CN")
x = np.linspace(-135, 250.0, 20)
M = utils.ndgrid(x - 12.5, np.r_[0.0])
N = utils.ndgrid(x + 12.5, np.r_[0.0])
A0loc = np.r_[-150, 0.0]
A1loc = np.r_[-130, 0.0]
# rxloc = [np.c_[M, np.zeros(20)], np.c_[N, np.zeros(20)]]
rx1 = dc.receivers.Dipole(M, N)
rx2 = dc.receivers.Dipole(M, N, data_type="apparent_resistivity")
src0 = dc.sources.Pole([rx1, rx2], A0loc)
src1 = dc.sources.Pole([rx1, rx2], A1loc)
survey = dc.survey.Survey([src0, src1])
survey.set_geometric_factor()
simulation = getattr(dc, self.formulation)(
mesh,
rhoMap=maps.IdentityMap(mesh),
storeJ=self.storeJ,
solver=Solver,
survey=survey,
bc_type=self.bc_type,
)
mSynth = np.ones(mesh.nC) * 1.0
data = simulation.make_synthetic_data(mSynth, add_noise=True)
# Now set up the problem to do some minimization
dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data)
reg = regularization.Tikhonov(mesh)
opt = optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=1e0)
inv = inversion.BaseInversion(invProb)
self.inv = inv
self.reg = reg
self.p = simulation
self.mesh = mesh
self.m0 = mSynth
self.survey = survey
self.dmis = dmis
self.data = data
def test_inv_mref_setting(self):
reg1 = regularization.Tikhonov(self.mesh)
reg2 = regularization.Tikhonov(self.mesh)
reg = reg1 + reg2
opt = optimization.ProjectedGNCG(
maxIter=10, lower=-10, upper=10, maxIterLS=20, maxIterCG=50, tolCG=1e-4
)
invProb = inverse_problem.BaseInvProblem(self.dmiscombo, reg, opt)
directives_list = [
directives.ScalingMultipleDataMisfits_ByEig(chi0_ratio=[0.01, 1.0], verbose=True),
directives.AlphasSmoothEstimate_ByEig(verbose=True),
directives.BetaEstimate_ByEig(beta0_ratio=1e-2),
directives.BetaSchedule(),
]
inv = inversion.BaseInversion(invProb, directiveList=directives_list)
m0 = self.model.mean() * np.ones_like(self.model)
mrec = inv.run(m0)
self.assertTrue(np.all(reg1.mref == m0))
self.assertTrue(np.all(reg2.mref == m0))
def setUp(self):
mesh = discretize.TensorMesh([4, 4, 4])
# Magnetic inducing field parameter (A,I,D)
B = [50000, 90, 0]
# Create a MAGsurvey
rx = mag.Point(np.vstack([[0.25, 0.25, 0.25], [-0.25, -0.25, 0.25]]))
srcField = mag.SourceField([rx], parameters=(B[0], B[1], B[2]))
survey = mag.Survey(srcField)
# Create the forward model operator
sim = mag.Simulation3DIntegral(mesh,
survey=survey,
chiMap=maps.IdentityMap(mesh))
# Compute forward model some data
m = np.random.rand(mesh.nC)
data = sim.make_synthetic_data(m, add_noise=True)
reg = regularization.Sparse(mesh)
reg.mref = np.zeros(mesh.nC)
reg.norms = np.c_[0, 1, 1, 1]
reg.eps_p, reg.eps_q = 1e-3, 1e-3
# Data misfit function
dmis = data_misfit.L2DataMisfit(data)
dmis.W = 1.0 / data.relative_error
# Add directives to the inversion
opt = optimization.ProjectedGNCG(maxIter=2,
lower=-10.0,
upper=10.0,
maxIterCG=2)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt)
self.mesh = mesh
self.invProb = invProb
self.sim = sim
def run(plotIt=True, survey_type="dipole-dipole", p=0.0, qx=2.0, qz=2.0):
np.random.seed(1)
# Initiate I/O class for DC
IO = DC.IO()
# Obtain ABMN locations
xmin, xmax = 0.0, 200.0
ymin, ymax = 0.0, 0.0
zmin, zmax = 0, 0
endl = np.array([[xmin, ymin, zmin], [xmax, ymax, zmax]])
# Generate DC survey object
survey = gen_DCIPsurvey(endl,
survey_type=survey_type,
dim=2,
a=10,
b=10,
n=10)
survey = IO.from_abmn_locations_to_survey(
survey.locations_a,
survey.locations_b,
survey.locations_m,
survey.locations_n,
survey_type,
data_dc_type="volt",
)
# Obtain 2D TensorMesh
mesh, actind = IO.set_mesh()
topo, mesh1D = genTopography(mesh, -10, 0, its=100)
actind = utils.surface2ind_topo(mesh, np.c_[mesh1D.vectorCCx, topo])
survey.drape_electrodes_on_topography(mesh, actind, option="top")
# Build a conductivity model
blk_inds_c = utils.model_builder.getIndicesSphere(np.r_[60.0, -25.0], 12.5,
mesh.gridCC)
blk_inds_r = utils.model_builder.getIndicesSphere(np.r_[140.0, -25.0],
12.5, mesh.gridCC)
layer_inds = mesh.gridCC[:, 1] > -5.0
sigma = np.ones(mesh.nC) * 1.0 / 100.0
sigma[blk_inds_c] = 1.0 / 10.0
sigma[blk_inds_r] = 1.0 / 1000.0
sigma[~actind] = 1.0 / 1e8
rho = 1.0 / sigma
# Show the true conductivity model
if plotIt:
fig = plt.figure(figsize=(12, 3))
ax = plt.subplot(111)
temp = rho.copy()
temp[~actind] = np.nan
out = mesh.plotImage(
temp,
grid=True,
ax=ax,
gridOpts={"alpha": 0.2},
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
)
ax.plot(survey.electrode_locations[:, 0],
survey.electrode_locations[:, 1], "k.")
ax.set_xlim(IO.grids[:, 0].min(), IO.grids[:, 0].max())
ax.set_ylim(-IO.grids[:, 1].max(), IO.grids[:, 1].min())
cb = plt.colorbar(out[0])
cb.set_label("Resistivity (ohm-m)")
ax.set_aspect("equal")
plt.show()
# Use Exponential Map: m = log(rho)
actmap = maps.InjectActiveCells(mesh,
indActive=actind,
valInactive=np.log(1e8))
mapping = maps.ExpMap(mesh) * actmap
# Generate mtrue
mtrue = np.log(rho[actind])
# Generate 2.5D DC problem
# "N" means potential is defined at nodes
prb = DC.Simulation2DNodal(mesh,
survey=survey,
rhoMap=mapping,
storeJ=True,
Solver=Solver,
verbose=True)
# Make synthetic DC data with 5% Gaussian noise
data = prb.make_synthetic_data(mtrue, relative_error=0.05, add_noise=True)
IO.data_dc = data.dobs
# Show apparent resisitivty pseudo-section
if plotIt:
IO.plotPseudoSection(data=data.dobs / IO.G,
data_type="apparent_resistivity")
# Show apparent resisitivty histogram
if plotIt:
fig = plt.figure()
out = hist(data.dobs / IO.G, bins=20)
plt.xlabel("Apparent Resisitivty ($\Omega$m)")
plt.show()
# Set initial model based upon histogram
m0 = np.ones(actmap.nP) * np.log(100.0)
# Set standard_deviation
# floor
eps = 10**(-3.2)
# percentage
relative = 0.05
dmisfit = data_misfit.L2DataMisfit(simulation=prb, data=data)
uncert = abs(data.dobs) * relative + eps
dmisfit.standard_deviation = uncert
# Map for a regularization
regmap = maps.IdentityMap(nP=int(actind.sum()))
# Related to inversion
reg = regularization.Sparse(mesh,
indActive=actind,
mapping=regmap,
gradientType="components")
# gradientType = 'components'
reg.norms = np.c_[p, qx, qz, 0.0]
IRLS = directives.Update_IRLS(max_irls_iterations=20,
minGNiter=1,
beta_search=False,
fix_Jmatrix=True)
opt = optimization.InexactGaussNewton(maxIter=40)
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
beta = directives.BetaSchedule(coolingFactor=5, coolingRate=2)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e0)
target = directives.TargetMisfit()
update_Jacobi = directives.UpdatePreconditioner()
inv = inversion.BaseInversion(invProb, directiveList=[betaest, IRLS])
prb.counter = opt.counter = utils.Counter()
opt.LSshorten = 0.5
opt.remember("xc")
# Run inversion
mopt = inv.run(m0)
rho_est = mapping * mopt
rho_est_l2 = mapping * invProb.l2model
rho_est[~actind] = np.nan
rho_est_l2[~actind] = np.nan
rho_true = rho.copy()
rho_true[~actind] = np.nan
# show recovered conductivity
if plotIt:
vmin, vmax = rho.min(), rho.max()
fig, ax = plt.subplots(3, 1, figsize=(20, 9))
out1 = mesh.plotImage(
rho_true,
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
ax=ax[0],
)
out2 = mesh.plotImage(
rho_est_l2,
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
ax=ax[1],
)
out3 = mesh.plotImage(
rho_est,
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
ax=ax[2],
)
out = [out1, out2, out3]
titles = ["True", "L2", ("L%d, Lx%d, Lz%d") % (p, qx, qz)]
for i in range(3):
ax[i].plot(survey.electrode_locations[:, 0],
survey.electrode_locations[:, 1], "kv")
ax[i].set_xlim(IO.grids[:, 0].min(), IO.grids[:, 0].max())
ax[i].set_ylim(-IO.grids[:, 1].max(), IO.grids[:, 1].min())
cb = plt.colorbar(out[i][0], ax=ax[i])
cb.set_label("Resistivity ($\Omega$m)")
ax[i].set_xlabel("Northing (m)")
ax[i].set_ylabel("Elevation (m)")
ax[i].set_aspect("equal")
ax[i].set_title(titles[i])
plt.tight_layout()
plt.show()
def run(plotIt=True):
nC = 40
de = 1.0
h = np.ones(nC) * de / nC
M = discretize.TensorMesh([h, h])
y = np.linspace(M.vectorCCy[0], M.vectorCCx[-1], int(np.floor(nC / 4)))
rlocs = np.c_[0 * y + M.vectorCCx[-1], y]
rx = tomo.Rx(rlocs)
source_list = [
tomo.Src(location=np.r_[M.vectorCCx[0], yi], receiver_list=[rx])
for yi in y
]
# phi model
phi0 = 0
phi1 = 0.65
phitrue = utils.model_builder.defineBlock(M.gridCC, [0.4, 0.6], [0.6, 0.4],
[phi1, phi0])
knownVolume = np.sum(phitrue * M.vol)
print("True Volume: {}".format(knownVolume))
# Set up true conductivity model and plot the model transform
sigma0 = np.exp(1)
sigma1 = 1e4
if plotIt:
fig, ax = plt.subplots(1, 1)
sigmaMapTest = maps.SelfConsistentEffectiveMedium(nP=1000,
sigma0=sigma0,
sigma1=sigma1,
rel_tol=1e-1,
maxIter=150)
testphis = np.linspace(0.0, 1.0, 1000)
sigetest = sigmaMapTest * testphis
ax.semilogy(testphis, sigetest)
ax.set_title("Model Transform")
ax.set_xlabel("$\\varphi$")
ax.set_ylabel("$\sigma$")
sigmaMap = maps.SelfConsistentEffectiveMedium(M,
sigma0=sigma0,
sigma1=sigma1)
# scale the slowness so it is on a ~linear scale
slownessMap = maps.LogMap(M) * sigmaMap
# set up the true sig model and log model dobs
sigtrue = sigmaMap * phitrue
# modt = Model.BaseModel(M);
slownesstrue = slownessMap * phitrue # true model (m = log(sigma))
# set up the problem and survey
survey = tomo.Survey(source_list)
problem = tomo.Simulation(M, survey=survey, slownessMap=slownessMap)
if plotIt:
fig, ax = plt.subplots(1, 1)
cb = plt.colorbar(M.plotImage(phitrue, ax=ax)[0], ax=ax)
survey.plot(ax=ax)
cb.set_label("$\\varphi$")
# get observed data
data = problem.make_synthetic_data(phitrue,
relative_error=0.03,
add_noise=True)
dpred = problem.dpred(np.zeros(M.nC))
# objective function pieces
reg = regularization.Tikhonov(M)
dmis = data_misfit.L2DataMisfit(simulation=problem, data=data)
dmisVol = Volume(mesh=M, knownVolume=knownVolume)
beta = 0.25
maxIter = 15
# without the volume regularization
opt = optimization.ProjectedGNCG(maxIter=maxIter, lower=0.0, upper=1.0)
opt.remember("xc")
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=beta)
inv = inversion.BaseInversion(invProb)
mopt1 = inv.run(np.zeros(M.nC) + 1e-16)
print("\nTotal recovered volume (no vol misfit term in inversion): "
"{}".format(dmisVol(mopt1)))
# with the volume regularization
vol_multiplier = 9e4
reg2 = reg
dmis2 = dmis + vol_multiplier * dmisVol
opt2 = optimization.ProjectedGNCG(maxIter=maxIter, lower=0.0, upper=1.0)
opt2.remember("xc")
invProb2 = inverse_problem.BaseInvProblem(dmis2, reg2, opt2, beta=beta)
inv2 = inversion.BaseInversion(invProb2)
mopt2 = inv2.run(np.zeros(M.nC) + 1e-16)
print("\nTotal volume (vol misfit term in inversion): {}".format(
dmisVol(mopt2)))
# plot results
if plotIt:
fig, ax = plt.subplots(1, 1)
ax.plot(data.dobs)
ax.plot(dpred)
ax.plot(problem.dpred(mopt1), "o")
ax.plot(problem.dpred(mopt2), "s")
ax.legend(["dobs", "dpred0", "dpred w/o Vol", "dpred with Vol"])
fig, ax = plt.subplots(1, 3, figsize=(16, 4))
im0 = M.plotImage(phitrue, ax=ax[0])[0]
im1 = M.plotImage(mopt1, ax=ax[1])[0]
im2 = M.plotImage(mopt2, ax=ax[2])[0]
for im in [im0, im1, im2]:
im.set_clim([0.0, phi1])
plt.colorbar(im0, ax=ax[0])
plt.colorbar(im1, ax=ax[1])
plt.colorbar(im2, ax=ax[2])
ax[0].set_title("true, vol: {:1.3e}".format(knownVolume))
ax[1].set_title("recovered(no Volume term), vol: {:1.3e} ".format(
dmisVol(mopt1)))
ax[2].set_title("recovered(with Volume term), vol: {:1.3e} ".format(
dmisVol(mopt2)))
plt.tight_layout()
def setUp(self):
ndv = -100
# Create a self.mesh
dx = 5.0
hxind = [(dx, 5, -1.3), (dx, 5), (dx, 5, 1.3)]
hyind = [(dx, 5, -1.3), (dx, 5), (dx, 5, 1.3)]
hzind = [(dx, 5, -1.3), (dx, 6)]
self.mesh = discretize.TensorMesh([hxind, hyind, hzind], "CCC")
# Get index of the center
midx = int(self.mesh.nCx / 2)
midy = int(self.mesh.nCy / 2)
# Lets create a simple Gaussian topo and set the active cells
[xx, yy] = np.meshgrid(self.mesh.vectorNx, self.mesh.vectorNy)
zz = -np.exp((xx**2 + yy**2) / 75**2) + self.mesh.vectorNz[-1]
# Go from topo to actv cells
topo = np.c_[utils.mkvc(xx), utils.mkvc(yy), utils.mkvc(zz)]
actv = utils.surface2ind_topo(self.mesh, topo, "N")
actv = np.where(actv)[0]
# Create active map to go from reduce space to full
self.actvMap = maps.InjectActiveCells(self.mesh, actv, -100)
nC = len(actv)
# Create and array of observation points
xr = np.linspace(-20.0, 20.0, 20)
yr = np.linspace(-20.0, 20.0, 20)
X, Y = np.meshgrid(xr, yr)
# Move the observation points 5m above the topo
Z = -np.exp((X**2 + Y**2) / 75**2) + self.mesh.vectorNz[-1] + 5.0
# Create a MAGsurvey
locXYZ = np.c_[utils.mkvc(X.T), utils.mkvc(Y.T), utils.mkvc(Z.T)]
rxLoc = gravity.Point(locXYZ)
srcField = gravity.SourceField([rxLoc])
survey = gravity.Survey(srcField)
# We can now create a density model and generate data
# Here a simple block in half-space
model = np.zeros((self.mesh.nCx, self.mesh.nCy, self.mesh.nCz))
model[(midx - 2):(midx + 2), (midy - 2):(midy + 2), -6:-2] = 0.5
model = utils.mkvc(model)
self.model = model[actv]
# Create active map to go from reduce set to full
actvMap = maps.InjectActiveCells(self.mesh, actv, ndv)
# Create reduced identity map
idenMap = maps.IdentityMap(nP=nC)
# Create the forward model operator
sim = gravity.Simulation3DIntegral(
self.mesh,
survey=survey,
rhoMap=idenMap,
actInd=actv,
store_sensitivities="ram",
)
# Compute linear forward operator and compute some data
# computing sensitivities to ram is best using dask processes
with dask.config.set(scheduler="processes"):
data = sim.make_synthetic_data(self.model,
relative_error=0.0,
noise_floor=0.001,
add_noise=True)
print(sim.G)
# Create a regularization
reg = regularization.Sparse(self.mesh, indActive=actv, mapping=idenMap)
reg.norms = np.c_[0, 0, 0, 0]
reg.gradientType = "component"
# reg.eps_p, reg.eps_q = 5e-2, 1e-2
# Data misfit function
dmis = data_misfit.L2DataMisfit(simulation=sim, data=data)
# Add directives to the inversion
opt = optimization.ProjectedGNCG(maxIter=100,
lower=-1.0,
upper=1.0,
maxIterLS=20,
maxIterCG=10,
tolCG=1e-3)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=1e8)
# Here is where the norms are applied
IRLS = directives.Update_IRLS(f_min_change=1e-4, minGNiter=1)
update_Jacobi = directives.UpdatePreconditioner()
sensitivity_weights = directives.UpdateSensitivityWeights(
everyIter=False)
self.inv = inversion.BaseInversion(
invProb, directiveList=[IRLS, sensitivity_weights, update_Jacobi])
self.sim = sim
def test_basic_inversion(self):
"""
Test to see if inversion recovers model
"""
h = [(2, 30)]
meshObj = discretize.TensorMesh((h, h, [(2, 10)]), x0="CCN")
mod = 0.00025 * np.ones(meshObj.nC)
mod[(meshObj.gridCC[:, 0] > -4.0)
& (meshObj.gridCC[:, 1] > -4.0)
& (meshObj.gridCC[:, 0] < 4.0)
& (meshObj.gridCC[:, 1] < 4.0)] = 0.001
times = np.logspace(-4, -2, 5)
waveObj = vrm.waveforms.SquarePulse(delt=0.02)
x, y = np.meshgrid(np.linspace(-17, 17, 16), np.linspace(-17, 17, 16))
x, y, z = mkvc(x), mkvc(y), 0.5 * np.ones(np.size(x))
receiver_list = [
vrm.Rx.Point(np.c_[x, y, z],
times=times,
fieldType="dbdt",
orientation="z")
]
txNodes = np.array([
[-20, -20, 0.001],
[20, -20, 0.001],
[20, 20, 0.001],
[-20, 20, 0.01],
[-20, -20, 0.001],
])
txList = [vrm.Src.LineCurrent(receiver_list, txNodes, 1.0, waveObj)]
Survey = vrm.Survey(txList)
Survey.t_active = np.zeros(Survey.nD, dtype=bool)
Survey.set_active_interval(-1e6, 1e6)
Problem = vrm.Simulation3DLinear(meshObj,
survey=Survey,
refinement_factor=2)
dobs = Problem.make_synthetic_data(mod)
Survey.noise_floor = 1e-11
dmis = data_misfit.L2DataMisfit(data=dobs, simulation=Problem)
W = mkvc((np.sum(np.array(Problem.A)**2, axis=0)))**0.25
reg = regularization.Simple(meshObj,
alpha_s=0.01,
alpha_x=1.0,
alpha_y=1.0,
alpha_z=1.0,
cell_weights=W)
opt = optimization.ProjectedGNCG(maxIter=20,
lower=0.0,
upper=1e-2,
maxIterLS=20,
tolCG=1e-4)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt)
directives = [
BetaSchedule(coolingFactor=2, coolingRate=1),
TargetMisfit()
]
inv = inversion.BaseInversion(invProb, directiveList=directives)
m0 = 1e-6 * np.ones(len(mod))
mrec = inv.run(m0)
dmis_final = np.sum(
(dmis.W.diagonal() * (mkvc(dobs) - Problem.fields(mrec)))**2)
mod_err_2 = np.sqrt(np.sum((mrec - mod)**2)) / np.size(mod)
mod_err_inf = np.max(np.abs(mrec - mod))
self.assertTrue(dmis_final < Survey.nD and mod_err_2 < 5e-6
and mod_err_inf < np.max(mod))
def setup_and_run_std_inv(mesh, dc_survey, dc_data, std_dc, conductivity_map,
ind_active, starting_conductivity_model):
"""Code to setup and run a standard inversion.
Parameters
----------
mesh : TYPE
DESCRIPTION.
dc_survey : TYPE
DESCRIPTION.
dc_data : TYPE
DESCRIPTION.
std_dc : TYPE
DESCRIPTION.
conductivity_map : TYPE
DESCRIPTION.
ind_active : TYPE
DESCRIPTION.
starting_conductivity_model : TYPE
DESCRIPTION.
Returns
-------
save_iteration : TYPE
DESCRIPTION.
save_dict_iteration : TYPE
DESCRIPTION.
"""
# Add standard deviations to data object
dc_data.standard_deviation = std_dc
# Define the simulation (physics of the problem)
dc_simulation = dc.simulation_2d.Simulation2DNodal(
mesh, survey=dc_survey, sigmaMap=conductivity_map, Solver=Solver)
# Define the data misfit.
dc_data_misfit = data_misfit.L2DataMisfit(data=dc_data,
simulation=dc_simulation)
# Define the regularization (model objective function)
dc_regularization = regularization.Simple(mesh,
indActive=ind_active,
mref=starting_conductivity_model,
alpha_s=0.01,
alpha_x=1,
alpha_y=1)
# Define how the optimization problem is solved. Here we will use a
# projected. Gauss-Newton approach that employs the conjugate gradient
# solver.
dc_optimization = optimization.ProjectedGNCG(maxIter=15,
lower=-np.inf,
upper=np.inf,
maxIterLS=20,
maxIterCG=10,
tolCG=1e-3)
# Here we define the inverse problem that is to be solved
dc_inverse_problem = inverse_problem.BaseInvProblem(
dc_data_misfit, dc_regularization, dc_optimization)
# Define inversion directives
# Apply and update sensitivity weighting as the model updates
update_sensitivity_weighting = directives.UpdateSensitivityWeights()
# Defining a starting value for the trade-off parameter (beta) between the
# data misfit and the regularization.
starting_beta = directives.BetaEstimate_ByEig(beta0_ratio=1e2)
# Set the rate of reduction in trade-off parameter (beta) each time the
# the inverse problem is solved. And set the number of Gauss-Newton
# iterations for each trade-off paramter value.
beta_schedule = directives.BetaSchedule(coolingFactor=10, coolingRate=1)
# Options for outputting recovered models and predicted data for each beta.
save_iteration = directives.SaveOutputEveryIteration(save_txt=False)
# save results from each iteration in a dict
save_dict_iteration = directives.SaveOutputDictEveryIteration(
saveOnDisk=False)
directives_list = [
update_sensitivity_weighting,
starting_beta,
beta_schedule,
save_iteration,
save_dict_iteration,
]
# Here we combine the inverse problem and the set of directives
dc_inversion = inversion.BaseInversion(dc_inverse_problem,
directiveList=directives_list)
# Run inversion
_ = dc_inversion.run(starting_conductivity_model)
return save_iteration, save_dict_iteration
dc_regularization = regularization.Simple(
mesh,
indActive=ind_active,
mref=starting_conductivity_model,
)
dc_regularization.mrefInSmooth = True # Include reference model in smoothness
# Define how the optimization problem is solved.
dc_optimization = optimization.InexactGaussNewton(maxIter=15,
maxIterCG=30,
tolCG=1e-2)
# Here we define the inverse problem that is to be solved
dc_inverse_problem = inverse_problem.BaseInvProblem(dc_data_misfit,
dc_regularization,
dc_optimization)
#################################################
# Define DC Inversion Directives
# ------------------------------
#
# Here we define any directives that are carried out during the inversion. This
# includes the cooling schedule for the trade-off parameter (beta), stopping
# criteria for the inversion and saving inversion results at each iteration.
#
#
# Apply and update sensitivity weighting as the model updates
update_sensitivity_weighting = directives.UpdateSensitivityWeights()
def run(plotIt=True, survey_type="dipole-dipole"):
np.random.seed(1)
# Initiate I/O class for DC
IO = DC.IO()
# Obtain ABMN locations
xmin, xmax = 0.0, 200.0
ymin, ymax = 0.0, 0.0
zmin, zmax = 0, 0
endl = np.array([[xmin, ymin, zmin], [xmax, ymax, zmax]])
# Generate DC survey object
survey = gen_DCIPsurvey(endl,
survey_type=survey_type,
dim=2,
a=10,
b=10,
n=10)
survey = IO.from_ambn_locations_to_survey(
survey.locations_a,
survey.locations_b,
survey.locations_m,
survey.locations_n,
survey_type,
data_dc_type="volt",
)
# Obtain 2D TensorMesh
mesh, actind = IO.set_mesh()
topo, mesh1D = genTopography(mesh, -10, 0, its=100)
actind = utils.surface2ind_topo(mesh, np.c_[mesh1D.vectorCCx, topo])
survey.drape_electrodes_on_topography(mesh, actind, option="top")
# Build a conductivity model
blk_inds_c = utils.model_builder.getIndicesSphere(np.r_[60.0, -25.0], 12.5,
mesh.gridCC)
blk_inds_r = utils.model_builder.getIndicesSphere(np.r_[140.0, -25.0],
12.5, mesh.gridCC)
layer_inds = mesh.gridCC[:, 1] > -5.0
sigma = np.ones(mesh.nC) * 1.0 / 100.0
sigma[blk_inds_c] = 1.0 / 10.0
sigma[blk_inds_r] = 1.0 / 1000.0
sigma[~actind] = 1.0 / 1e8
rho = 1.0 / sigma
# Show the true conductivity model
if plotIt:
fig = plt.figure(figsize=(12, 3))
ax = plt.subplot(111)
temp = rho.copy()
temp[~actind] = np.nan
out = mesh.plotImage(
temp,
grid=True,
ax=ax,
gridOpts={"alpha": 0.2},
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
)
ax.plot(survey.electrode_locations[:, 0],
survey.electrode_locations[:, 1], "k.")
ax.set_xlim(IO.grids[:, 0].min(), IO.grids[:, 0].max())
ax.set_ylim(-IO.grids[:, 1].max(), IO.grids[:, 1].min())
cb = plt.colorbar(out[0])
cb.set_label("Resistivity (ohm-m)")
ax.set_aspect("equal")
plt.show()
# Use Exponential Map: m = log(rho)
actmap = maps.InjectActiveCells(mesh,
indActive=actind,
valInactive=np.log(1e8))
mapping = maps.ExpMap(mesh) * actmap
# Generate mtrue
mtrue = np.log(rho[actind])
# Generate 2.5D DC problem
# "N" means potential is defined at nodes
prb = DC.Simulation2DNodal(mesh,
survey=survey,
rhoMap=mapping,
storeJ=True,
Solver=Solver,
verbose=True)
geometric_factor = survey.set_geometric_factor(
data_type="apparent_resistivity",
survey_type="dipole-dipole",
space_type="half-space",
)
# Make synthetic DC data with 5% Gaussian noise
data = prb.make_synthetic_data(mtrue, relative_error=0.05, add_noise=True)
IO.data_dc = data.dobs
# Show apparent resisitivty pseudo-section
if plotIt:
IO.plotPseudoSection(data=data.dobs, data_type="apparent_resistivity")
# Show apparent resisitivty histogram
if plotIt:
fig = plt.figure()
out = hist(data.dobs, bins=20)
plt.xlabel("Apparent Resisitivty ($\Omega$m)")
plt.show()
# Set initial model based upon histogram
m0 = np.ones(actmap.nP) * np.log(100.0)
# Set standard_deviation
# floor (10 ohm-m)
eps = 1.0
# percentage
relative = 0.05
dmisfit = data_misfit.L2DataMisfit(simulation=prb, data=data)
uncert = abs(data.dobs) * relative + eps
dmisfit.standard_deviation = uncert
# Map for a regularization
regmap = maps.IdentityMap(nP=int(actind.sum()))
# Related to inversion
reg = regularization.Sparse(mesh, indActive=actind, mapping=regmap)
opt = optimization.InexactGaussNewton(maxIter=15)
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
beta = directives.BetaSchedule(coolingFactor=5, coolingRate=2)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e0)
target = directives.TargetMisfit()
updateSensW = directives.UpdateSensitivityWeights()
update_Jacobi = directives.UpdatePreconditioner()
inv = inversion.BaseInversion(
invProb,
directiveList=[beta, target, updateSensW, betaest, update_Jacobi])
prb.counter = opt.counter = utils.Counter()
opt.LSshorten = 0.5
opt.remember("xc")
# Run inversion
mopt = inv.run(m0)
# Get diag(JtJ)
mask_inds = np.ones(mesh.nC, dtype=bool)
jtj = np.sqrt(updateSensW.JtJdiag[0])
jtj /= jtj.max()
temp = np.ones_like(jtj, dtype=bool)
temp[jtj > 0.005] = False
mask_inds[actind] = temp
actind_final = np.logical_and(actind, ~mask_inds)
jtj_cc = np.ones(mesh.nC) * np.nan
jtj_cc[actind] = jtj
# Show the sensitivity
if plotIt:
fig = plt.figure(figsize=(12, 3))
ax = plt.subplot(111)
temp = rho.copy()
temp[~actind] = np.nan
out = mesh.plotImage(
jtj_cc,
grid=True,
ax=ax,
gridOpts={"alpha": 0.2},
clim=(0.005, 0.5),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
)
ax.plot(survey.electrode_locations[:, 0],
survey.electrode_locations[:, 1], "k.")
ax.set_xlim(IO.grids[:, 0].min(), IO.grids[:, 0].max())
ax.set_ylim(-IO.grids[:, 1].max(), IO.grids[:, 1].min())
cb = plt.colorbar(out[0])
cb.set_label("Sensitivity")
ax.set_aspect("equal")
plt.show()
# Convert obtained inversion model to resistivity
# rho = M(m), where M(.) is a mapping
rho_est = mapping * mopt
rho_est[~actind_final] = np.nan
rho_true = rho.copy()
rho_true[~actind_final] = np.nan
# show recovered conductivity
if plotIt:
vmin, vmax = rho.min(), rho.max()
fig, ax = plt.subplots(2, 1, figsize=(20, 6))
out1 = mesh.plotImage(
rho_true,
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
ax=ax[0],
)
out2 = mesh.plotImage(
rho_est,
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
ax=ax[1],
)
out = [out1, out2]
for i in range(2):
ax[i].plot(survey.electrode_locations[:, 0],
survey.electrode_locations[:, 1], "kv")
ax[i].set_xlim(IO.grids[:, 0].min(), IO.grids[:, 0].max())
ax[i].set_ylim(-IO.grids[:, 1].max(), IO.grids[:, 1].min())
cb = plt.colorbar(out[i][0], ax=ax[i])
cb.set_label("Resistivity ($\Omega$m)")
ax[i].set_xlabel("Northing (m)")
ax[i].set_ylabel("Elevation (m)")
ax[i].set_aspect("equal")
plt.tight_layout()
plt.show()
def run(plotIt=True, saveFig=False):
# Set up cylindrically symmeric mesh
cs, ncx, ncz, npad = 10.0, 15, 25, 13 # padded cyl mesh
hx = [(cs, ncx), (cs, npad, 1.3)]
hz = [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)]
mesh = discretize.CylMesh([hx, 1, hz], "00C")
# Conductivity model
layerz = np.r_[-200.0, -100.0]
layer = (mesh.vectorCCz >= layerz[0]) & (mesh.vectorCCz <= layerz[1])
active = mesh.vectorCCz < 0.0
sig_half = 1e-2 # Half-space conductivity
sig_air = 1e-8 # Air conductivity
sig_layer = 5e-2 # Layer conductivity
sigma = np.ones(mesh.nCz) * sig_air
sigma[active] = sig_half
sigma[layer] = sig_layer
# Mapping
actMap = maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
mapping = maps.ExpMap(mesh) * maps.SurjectVertical1D(mesh) * actMap
mtrue = np.log(sigma[active])
# ----- FDEM problem & survey ----- #
rxlocs = utils.ndgrid([np.r_[50.0], np.r_[0], np.r_[0.0]])
bzr = FDEM.Rx.PointMagneticFluxDensitySecondary(rxlocs, "z", "real")
bzi = FDEM.Rx.PointMagneticFluxDensitySecondary(rxlocs, "z", "imag")
freqs = np.logspace(2, 3, 5)
srcLoc = np.array([0.0, 0.0, 0.0])
print(
"min skin depth = ",
500.0 / np.sqrt(freqs.max() * sig_half),
"max skin depth = ",
500.0 / np.sqrt(freqs.min() * sig_half),
)
print(
"max x ",
mesh.vectorCCx.max(),
"min z ",
mesh.vectorCCz.min(),
"max z ",
mesh.vectorCCz.max(),
)
source_list = [
FDEM.Src.MagDipole([bzr, bzi], freq, srcLoc, orientation="Z") for freq in freqs
]
surveyFD = FDEM.Survey(source_list)
prbFD = FDEM.Simulation3DMagneticFluxDensity(
mesh, survey=surveyFD, sigmaMap=mapping, solver=Solver
)
rel_err = 0.03
dataFD = prbFD.make_synthetic_data(mtrue, relative_error=rel_err, add_noise=True)
dataFD.noise_floor = np.linalg.norm(dataFD.dclean) * 1e-5
# FDEM inversion
np.random.seed(1)
dmisfit = data_misfit.L2DataMisfit(simulation=prbFD, data=dataFD)
regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
reg = regularization.Simple(regMesh)
opt = optimization.InexactGaussNewton(maxIterCG=10)
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
# Inversion Directives
beta = directives.BetaSchedule(coolingFactor=4, coolingRate=3)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.0, seed=518936)
target = directives.TargetMisfit()
directiveList = [beta, betaest, target]
inv = inversion.BaseInversion(invProb, directiveList=directiveList)
m0 = np.log(np.ones(mtrue.size) * sig_half)
reg.alpha_s = 5e-1
reg.alpha_x = 1.0
prbFD.counter = opt.counter = utils.Counter()
opt.remember("xc")
moptFD = inv.run(m0)
# TDEM problem
times = np.logspace(-4, np.log10(2e-3), 10)
print(
"min diffusion distance ",
1.28 * np.sqrt(times.min() / (sig_half * mu_0)),
"max diffusion distance ",
1.28 * np.sqrt(times.max() / (sig_half * mu_0)),
)
rx = TDEM.Rx.PointMagneticFluxDensity(rxlocs, times, "z")
src = TDEM.Src.MagDipole(
[rx],
waveform=TDEM.Src.StepOffWaveform(),
location=srcLoc, # same src location as FDEM problem
)
surveyTD = TDEM.Survey([src])
prbTD = TDEM.Simulation3DMagneticFluxDensity(
mesh, survey=surveyTD, sigmaMap=mapping, solver=Solver
)
prbTD.time_steps = [(5e-5, 10), (1e-4, 10), (5e-4, 10)]
rel_err = 0.03
dataTD = prbTD.make_synthetic_data(mtrue, relative_error=rel_err, add_noise=True)
dataTD.noise_floor = np.linalg.norm(dataTD.dclean) * 1e-5
# TDEM inversion
dmisfit = data_misfit.L2DataMisfit(simulation=prbTD, data=dataTD)
regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
reg = regularization.Simple(regMesh)
opt = optimization.InexactGaussNewton(maxIterCG=10)
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
# directives
beta = directives.BetaSchedule(coolingFactor=4, coolingRate=3)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.0, seed=518936)
target = directives.TargetMisfit()
directiveList = [beta, betaest, target]
inv = inversion.BaseInversion(invProb, directiveList=directiveList)
m0 = np.log(np.ones(mtrue.size) * sig_half)
reg.alpha_s = 5e-1
reg.alpha_x = 1.0
prbTD.counter = opt.counter = utils.Counter()
opt.remember("xc")
moptTD = inv.run(m0)
# Plot the results
if plotIt:
plt.figure(figsize=(10, 8))
ax0 = plt.subplot2grid((2, 2), (0, 0), rowspan=2)
ax1 = plt.subplot2grid((2, 2), (0, 1))
ax2 = plt.subplot2grid((2, 2), (1, 1))
fs = 13 # fontsize
matplotlib.rcParams["font.size"] = fs
# Plot the model
# z_true = np.repeat(mesh.vectorCCz[active][1:], 2, axis=0)
# z_true = np.r_[mesh.vectorCCz[active][0], z_true, mesh.vectorCCz[active][-1]]
activeN = mesh.vectorNz <= 0.0 + cs / 2.0
z_true = np.repeat(mesh.vectorNz[activeN][1:-1], 2, axis=0)
z_true = np.r_[mesh.vectorNz[activeN][0], z_true, mesh.vectorNz[activeN][-1]]
sigma_true = np.repeat(sigma[active], 2, axis=0)
ax0.semilogx(sigma_true, z_true, "k-", lw=2, label="True")
ax0.semilogx(
np.exp(moptFD),
mesh.vectorCCz[active],
"bo",
ms=6,
markeredgecolor="k",
markeredgewidth=0.5,
label="FDEM",
)
ax0.semilogx(
np.exp(moptTD),
mesh.vectorCCz[active],
"r*",
ms=10,
markeredgecolor="k",
markeredgewidth=0.5,
label="TDEM",
)
ax0.set_ylim(-700, 0)
ax0.set_xlim(5e-3, 1e-1)
ax0.set_xlabel("Conductivity (S/m)", fontsize=fs)
ax0.set_ylabel("Depth (m)", fontsize=fs)
ax0.grid(which="both", color="k", alpha=0.5, linestyle="-", linewidth=0.2)
ax0.legend(fontsize=fs, loc=4)
# plot the data misfits - negative b/c we choose positive to be in the
# direction of primary
ax1.plot(freqs, -dataFD.dobs[::2], "k-", lw=2, label="Obs (real)")
ax1.plot(freqs, -dataFD.dobs[1::2], "k--", lw=2, label="Obs (imag)")
dpredFD = prbFD.dpred(moptTD)
ax1.loglog(
freqs,
-dpredFD[::2],
"bo",
ms=6,
markeredgecolor="k",
markeredgewidth=0.5,
label="Pred (real)",
)
ax1.loglog(
freqs, -dpredFD[1::2], "b+", ms=10, markeredgewidth=2.0, label="Pred (imag)"
)
ax2.loglog(times, dataTD.dobs, "k-", lw=2, label="Obs")
ax2.loglog(
times,
prbTD.dpred(moptTD),
"r*",
ms=10,
markeredgecolor="k",
markeredgewidth=0.5,
label="Pred",
)
ax2.set_xlim(times.min() - 1e-5, times.max() + 1e-4)
# Labels, gridlines, etc
ax2.grid(which="both", alpha=0.5, linestyle="-", linewidth=0.2)
ax1.grid(which="both", alpha=0.5, linestyle="-", linewidth=0.2)
ax1.set_xlabel("Frequency (Hz)", fontsize=fs)
ax1.set_ylabel("Vertical magnetic field (-T)", fontsize=fs)
ax2.set_xlabel("Time (s)", fontsize=fs)
ax2.set_ylabel("Vertical magnetic field (T)", fontsize=fs)
ax2.legend(fontsize=fs, loc=3)
ax1.legend(fontsize=fs, loc=3)
ax1.set_xlim(freqs.max() + 1e2, freqs.min() - 1e1)
ax0.set_title("(a) Recovered Models", fontsize=fs)
ax1.set_title("(b) FDEM observed vs. predicted", fontsize=fs)
ax2.set_title("(c) TDEM observed vs. predicted", fontsize=fs)
plt.tight_layout(pad=1.5)
if saveFig is True:
plt.savefig("example1.png", dpi=600)
def setUp(self):
cs = 25.0
hx = [(cs, 0, -1.3), (cs, 21), (cs, 0, 1.3)]
hy = [(cs, 0, -1.3), (cs, 21), (cs, 0, 1.3)]
hz = [(cs, 0, -1.3), (cs, 20), (cs, 0, 1.3)]
mesh = discretize.TensorMesh([hx, hy, hz], x0="CCC")
blkind0 = utils.model_builder.getIndicesSphere(
np.r_[-100.0, -100.0, -200.0], 75.0, mesh.gridCC)
blkind1 = utils.model_builder.getIndicesSphere(
np.r_[100.0, 100.0, -200.0], 75.0, mesh.gridCC)
sigma = np.ones(mesh.nC) * 1e-2
airind = mesh.gridCC[:, 2] > 0.0
sigma[airind] = 1e-8
eta = np.zeros(mesh.nC)
tau = np.ones_like(sigma) * 1.0
c = np.ones_like(sigma) * 0.5
eta[blkind0] = 0.1
eta[blkind1] = 0.1
tau[blkind0] = 0.1
tau[blkind1] = 0.01
actmapeta = maps.InjectActiveCells(mesh, ~airind, 0.0)
actmaptau = maps.InjectActiveCells(mesh, ~airind, 1.0)
actmapc = maps.InjectActiveCells(mesh, ~airind, 1.0)
x = mesh.vectorCCx[(mesh.vectorCCx > -155.0)
& (mesh.vectorCCx < 155.0)]
y = mesh.vectorCCy[(mesh.vectorCCy > -155.0)
& (mesh.vectorCCy < 155.0)]
Aloc = np.r_[-200.0, 0.0, 0.0]
Bloc = np.r_[200.0, 0.0, 0.0]
M = utils.ndgrid(x - 25.0, y, np.r_[0.0])
N = utils.ndgrid(x + 25.0, y, np.r_[0.0])
times = np.arange(10) * 1e-3 + 1e-3
rx = sip.receivers.Dipole(M, N, times)
src = sip.sources.Dipole([rx], Aloc, Bloc)
survey = sip.Survey([src])
wires = maps.Wires(("eta", actmapeta.nP), ("taui", actmaptau.nP),
("c", actmapc.nP))
problem = sip.Simulation3DNodal(
mesh,
survey=survey,
sigma=sigma,
etaMap=actmapeta * wires.eta,
tauiMap=actmaptau * wires.taui,
cMap=actmapc * wires.c,
actinds=~airind,
storeJ=False,
verbose=False,
)
problem.solver = Solver
mSynth = np.r_[eta[~airind], 1.0 / tau[~airind], c[~airind]]
dobs = problem.make_synthetic_data(mSynth, add_noise=True)
# Now set up the problem to do some minimization
dmis = data_misfit.L2DataMisfit(data=dobs, simulation=problem)
reg_eta = regularization.Sparse(mesh,
mapping=wires.eta,
indActive=~airind)
reg_taui = regularization.Sparse(mesh,
mapping=wires.taui,
indActive=~airind)
reg_c = regularization.Sparse(mesh, mapping=wires.c, indActive=~airind)
reg = reg_eta + reg_taui + reg_c
opt = optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=1e4)
inv = inversion.BaseInversion(invProb)
self.inv = inv
self.reg = reg
self.p = problem
self.mesh = mesh
self.m0 = mSynth
self.survey = survey
self.dmis = dmis
self.dobs = dobs
reg = reg_p + reg_s + reg_t
reg.mref = np.zeros(3 * nC)
# Data misfit function
dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object)
dmis.W = 1.0 / data_object.standard_deviation
# Add directives to the inversion
opt = optimization.ProjectedGNCG(maxIter=10,
lower=-10,
upper=10.0,
maxIterLS=20,
maxIterCG=20,
tolCG=1e-4)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt)
# A list of directive to control the inverson
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e1)
# Add sensitivity weights
sensitivity_weights = directives.UpdateSensitivityWeights()
# Here is where the norms are applied
# Use a threshold parameter empirically based on the distribution of
# model parameters
IRLS = directives.Update_IRLS(f_min_change=1e-3,
max_irls_iterations=2,
beta_tol=5e-1)
# Pre-conditioner
def setUp(self):
cs = 25.0
hx = [(cs, 0, -1.3), (cs, 21), (cs, 0, 1.3)]
hy = [(cs, 0, -1.3), (cs, 21), (cs, 0, 1.3)]
hz = [(cs, 0, -1.3), (cs, 20)]
mesh = discretize.TensorMesh([hx, hy, hz], x0="CCN")
blkind0 = utils.model_builder.getIndicesSphere(
np.r_[-100.0, -100.0, -200.0], 75.0, mesh.gridCC)
blkind1 = utils.model_builder.getIndicesSphere(
np.r_[100.0, 100.0, -200.0], 75.0, mesh.gridCC)
sigma = np.ones(mesh.nC) * 1e-2
eta = np.zeros(mesh.nC)
tau = np.ones_like(sigma) * 1.0
eta[blkind0] = 0.1
eta[blkind1] = 0.1
tau[blkind0] = 0.1
tau[blkind1] = 0.01
x = mesh.vectorCCx[(mesh.vectorCCx > -155.0)
& (mesh.vectorCCx < 155.0)]
y = mesh.vectorCCy[(mesh.vectorCCy > -155.0)
& (mesh.vectorCCy < 155.0)]
Aloc = np.r_[-200.0, 0.0, 0.0]
Bloc = np.r_[200.0, 0.0, 0.0]
M = utils.ndgrid(x - 25.0, y, np.r_[0.0])
N = utils.ndgrid(x + 25.0, y, np.r_[0.0])
times = np.arange(10) * 1e-3 + 1e-3
rx = sip.receivers.Dipole(M, N, times)
print(rx.nD)
print(rx.locations)
src = sip.sources.Dipole([rx], Aloc, Bloc)
survey = sip.Survey([src])
print(f"Survey ND = {survey.nD}")
print(f"Survey ND = {src.nD}")
wires = maps.Wires(("eta", mesh.nC), ("taui", mesh.nC))
problem = sip.Simulation3DCellCentered(
mesh,
survey=survey,
rho=1.0 / sigma,
etaMap=wires.eta,
tauiMap=wires.taui,
storeJ=False,
)
problem.solver = Solver
mSynth = np.r_[eta, 1.0 / tau]
problem.model = mSynth
dobs = problem.make_synthetic_data(mSynth, add_noise=True)
# Now set up the problem to do some minimization
dmis = data_misfit.L2DataMisfit(data=dobs, simulation=problem)
reg = regularization.Tikhonov(mesh)
opt = optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt, beta=1e4)
inv = inversion.BaseInversion(invProb)
self.inv = inv
self.reg = reg
self.p = problem
self.mesh = mesh
self.m0 = mSynth
self.survey = survey
self.dmis = dmis
self.dobs = dobs
def run(plotIt=True):
# Define the inducing field parameter
H0 = (50000, 90, 0)
# Create a mesh
dx = 5.0
hxind = [(dx, 5, -1.3), (dx, 10), (dx, 5, 1.3)]
hyind = [(dx, 5, -1.3), (dx, 10), (dx, 5, 1.3)]
hzind = [(dx, 5, -1.3), (dx, 10)]
mesh = TensorMesh([hxind, hyind, hzind], "CCC")
# Get index of the center
midx = int(mesh.nCx / 2)
midy = int(mesh.nCy / 2)
# Lets create a simple Gaussian topo and set the active cells
[xx, yy] = np.meshgrid(mesh.vectorNx, mesh.vectorNy)
zz = -np.exp((xx**2 + yy**2) / 75**2) + mesh.vectorNz[-1]
# We would usually load a topofile
topo = np.c_[utils.mkvc(xx), utils.mkvc(yy), utils.mkvc(zz)]
# Go from topo to array of indices of active cells
actv = utils.surface2ind_topo(mesh, topo, "N")
actv = np.where(actv)[0]
nC = len(actv)
# Create and array of observation points
xr = np.linspace(-20.0, 20.0, 20)
yr = np.linspace(-20.0, 20.0, 20)
X, Y = np.meshgrid(xr, yr)
# Move the observation points 5m above the topo
Z = -np.exp((X**2 + Y**2) / 75**2) + mesh.vectorNz[-1] + 5.0
# Create a MAGsurvey
rxLoc = np.c_[utils.mkvc(X.T), utils.mkvc(Y.T), utils.mkvc(Z.T)]
rxLoc = magnetics.receivers.Point(rxLoc, components=["tmi"])
srcField = magnetics.sources.SourceField(receiver_list=[rxLoc],
parameters=H0)
survey = magnetics.survey.Survey(srcField)
# We can now create a susceptibility model and generate data
# Here a simple block in half-space
model = np.zeros((mesh.nCx, mesh.nCy, mesh.nCz))
model[(midx - 2):(midx + 2), (midy - 2):(midy + 2), -6:-2] = 0.02
model = utils.mkvc(model)
model = model[actv]
# Create active map to go from reduce set to full
actvMap = maps.InjectActiveCells(mesh, actv, -100)
# Create reduced identity map
idenMap = maps.IdentityMap(nP=nC)
# Create the forward model operator
simulation = magnetics.simulation.Simulation3DIntegral(
survey=survey,
mesh=mesh,
chiMap=idenMap,
actInd=actv,
)
# Compute linear forward operator and compute some data
d = simulation.dpred(model)
# Add noise and uncertainties
# We add some random Gaussian noise (1nT)
synthetic_data = d + np.random.randn(len(d))
wd = np.ones(len(synthetic_data)) * 1.0 # Assign flat uncertainties
data_object = data.Data(survey, dobs=synthetic_data, noise_floor=wd)
# Create a regularization
reg = regularization.Sparse(mesh, indActive=actv, mapping=idenMap)
reg.mref = np.zeros(nC)
reg.norms = np.c_[0, 0, 0, 0]
# reg.eps_p, reg.eps_q = 1e-0, 1e-0
# Create sensitivity weights from our linear forward operator
rxLoc = survey.source_field.receiver_list[0].locations
m0 = np.ones(nC) * 1e-4 # Starting model
# Data misfit function
dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object)
dmis.W = 1 / wd
# Add directives to the inversion
opt = optimization.ProjectedGNCG(maxIter=20,
lower=0.0,
upper=1.0,
maxIterLS=20,
maxIterCG=20,
tolCG=1e-3)
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e-1)
# Here is where the norms are applied
# Use pick a threshold parameter empirically based on the distribution of
# model parameters
IRLS = directives.Update_IRLS(f_min_change=1e-3, max_irls_iterations=40)
saveDict = directives.SaveOutputEveryIteration(save_txt=False)
update_Jacobi = directives.UpdatePreconditioner()
# Add sensitivity weights
sensitivity_weights = directives.UpdateSensitivityWeights(everyIter=False)
inv = inversion.BaseInversion(
invProb,
directiveList=[
sensitivity_weights, IRLS, betaest, update_Jacobi, saveDict
],
)
# Run the inversion
mrec = inv.run(m0)
if plotIt:
# Here is the recovered susceptibility model
ypanel = midx
zpanel = -5
m_l2 = actvMap * invProb.l2model
m_l2[m_l2 == -100] = np.nan
m_lp = actvMap * mrec
m_lp[m_lp == -100] = np.nan
m_true = actvMap * model
m_true[m_true == -100] = np.nan
# Plot the data
utils.plot_utils.plot2Ddata(rxLoc, d)
plt.figure()
# Plot L2 model
ax = plt.subplot(321)
mesh.plotSlice(
m_l2,
ax=ax,
normal="Z",
ind=zpanel,
grid=True,
clim=(model.min(), model.max()),
)
plt.plot(
([mesh.vectorCCx[0], mesh.vectorCCx[-1]]),
([mesh.vectorCCy[ypanel], mesh.vectorCCy[ypanel]]),
color="w",
)
plt.title("Plan l2-model.")
plt.gca().set_aspect("equal")
plt.ylabel("y")
ax.xaxis.set_visible(False)
plt.gca().set_aspect("equal", adjustable="box")
# Vertica section
ax = plt.subplot(322)
mesh.plotSlice(
m_l2,
ax=ax,
normal="Y",
ind=midx,
grid=True,
clim=(model.min(), model.max()),
)
plt.plot(
([mesh.vectorCCx[0], mesh.vectorCCx[-1]]),
([mesh.vectorCCz[zpanel], mesh.vectorCCz[zpanel]]),
color="w",
)
plt.title("E-W l2-model.")
plt.gca().set_aspect("equal")
ax.xaxis.set_visible(False)
plt.ylabel("z")
plt.gca().set_aspect("equal", adjustable="box")
# Plot Lp model
ax = plt.subplot(323)
mesh.plotSlice(
m_lp,
ax=ax,
normal="Z",
ind=zpanel,
grid=True,
clim=(model.min(), model.max()),
)
plt.plot(
([mesh.vectorCCx[0], mesh.vectorCCx[-1]]),
([mesh.vectorCCy[ypanel], mesh.vectorCCy[ypanel]]),
color="w",
)
plt.title("Plan lp-model.")
plt.gca().set_aspect("equal")
ax.xaxis.set_visible(False)
plt.ylabel("y")
plt.gca().set_aspect("equal", adjustable="box")
# Vertical section
ax = plt.subplot(324)
mesh.plotSlice(
m_lp,
ax=ax,
normal="Y",
ind=midx,
grid=True,
clim=(model.min(), model.max()),
)
plt.plot(
([mesh.vectorCCx[0], mesh.vectorCCx[-1]]),
([mesh.vectorCCz[zpanel], mesh.vectorCCz[zpanel]]),
color="w",
)
plt.title("E-W lp-model.")
plt.gca().set_aspect("equal")
ax.xaxis.set_visible(False)
plt.ylabel("z")
plt.gca().set_aspect("equal", adjustable="box")
# Plot True model
ax = plt.subplot(325)
mesh.plotSlice(
m_true,
ax=ax,
normal="Z",
ind=zpanel,
grid=True,
clim=(model.min(), model.max()),
)
plt.plot(
([mesh.vectorCCx[0], mesh.vectorCCx[-1]]),
([mesh.vectorCCy[ypanel], mesh.vectorCCy[ypanel]]),
color="w",
)
plt.title("Plan true model.")
plt.gca().set_aspect("equal")
plt.xlabel("x")
plt.ylabel("y")
plt.gca().set_aspect("equal", adjustable="box")
# Vertical section
ax = plt.subplot(326)
mesh.plotSlice(
m_true,
ax=ax,
normal="Y",
ind=midx,
grid=True,
clim=(model.min(), model.max()),
)
plt.plot(
([mesh.vectorCCx[0], mesh.vectorCCx[-1]]),
([mesh.vectorCCz[zpanel], mesh.vectorCCz[zpanel]]),
color="w",
)
plt.title("E-W true model.")
plt.gca().set_aspect("equal")
plt.xlabel("x")
plt.ylabel("z")
plt.gca().set_aspect("equal", adjustable="box")
# Plot convergence curves
fig, axs = plt.figure(), plt.subplot()
axs.plot(saveDict.phi_d, "k", lw=2)
axs.plot(
np.r_[IRLS.iterStart, IRLS.iterStart],
np.r_[0, np.max(saveDict.phi_d)],
"k:",
)
twin = axs.twinx()
twin.plot(saveDict.phi_m, "k--", lw=2)
axs.text(
IRLS.iterStart,
0,
"IRLS Steps",
va="bottom",
ha="center",
rotation="vertical",
size=12,
bbox={"facecolor": "white"},
)
axs.set_ylabel("$\phi_d$", size=16, rotation=0)
axs.set_xlabel("Iterations", size=14)
twin.set_ylabel("$\phi_m$", size=16, rotation=0)
def run_inversion(
m0,
survey,
actind,
mesh,
wires,
std,
eps,
maxIter=15,
beta0_ratio=1e0,
coolingFactor=2,
coolingRate=2,
maxIterLS=20,
maxIterCG=10,
LSshorten=0.5,
eta_lower=1e-5,
eta_upper=1,
tau_lower=1e-6,
tau_upper=10.0,
c_lower=1e-2,
c_upper=1.0,
is_log_tau=True,
is_log_c=True,
is_log_eta=True,
mref=None,
alpha_s=1e-4,
alpha_x=1e0,
alpha_y=1e0,
alpha_z=1e0,
):
"""
Run Spectral Spectral IP inversion
"""
dmisfit = data_misfit.L2DataMisfit(survey)
uncert = abs(survey.dobs) * std + eps
dmisfit.W = 1.0 / uncert
# Map for a regularization
# Related to inversion
# Set Upper and Lower bounds
e = np.ones(actind.sum())
if np.isscalar(eta_lower):
eta_lower = e * eta_lower
if np.isscalar(tau_lower):
tau_lower = e * tau_lower
if np.isscalar(c_lower):
c_lower = e * c_lower
if np.isscalar(eta_upper):
eta_upper = e * eta_upper
if np.isscalar(tau_upper):
tau_upper = e * tau_upper
if np.isscalar(c_upper):
c_upper = e * c_upper
if is_log_eta:
eta_upper = np.log(eta_upper)
eta_lower = np.log(eta_lower)
if is_log_tau:
tau_upper = np.log(tau_upper)
tau_lower = np.log(tau_lower)
if is_log_c:
c_upper = np.log(c_upper)
c_lower = np.log(c_lower)
m_upper = np.r_[eta_upper, tau_upper, c_upper]
m_lower = np.r_[eta_lower, tau_lower, c_lower]
# Set up regularization
reg_eta = regularization.Simple(mesh, mapping=wires.eta, indActive=actind)
reg_tau = regularization.Simple(mesh, mapping=wires.tau, indActive=actind)
reg_c = regularization.Simple(mesh, mapping=wires.c, indActive=actind)
# Todo:
reg_eta.alpha_s = alpha_s
reg_tau.alpha_s = 0.0
reg_c.alpha_s = 0.0
reg_eta.alpha_x = alpha_x
reg_tau.alpha_x = alpha_x
reg_c.alpha_x = alpha_x
reg_eta.alpha_y = alpha_y
reg_tau.alpha_y = alpha_y
reg_c.alpha_y = alpha_y
reg_eta.alpha_z = alpha_z
reg_tau.alpha_z = alpha_z
reg_c.alpha_z = alpha_z
reg = reg_eta + reg_tau + reg_c
# Use Projected Gauss Newton scheme
opt = optimization.ProjectedGNCG(
maxIter=maxIter,
upper=m_upper,
lower=m_lower,
maxIterLS=maxIterLS,
maxIterCG=maxIterCG,
LSshorten=LSshorten,
)
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
beta = directives.BetaSchedule(coolingFactor=coolingFactor, coolingRate=coolingRate)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=beta0_ratio)
target = directives.TargetMisfit()
directiveList = [beta, betaest, target]
inv = inversion.BaseInversion(invProb, directiveList=directiveList)
opt.LSshorten = 0.5
opt.remember("xc")
# Run inversion
mopt = inv.run(m0)
return mopt, invProb.dpred
def run(
plotIt=True,
survey_type="dipole-dipole",
rho_background=1e3,
rho_block=1e2,
block_x0=100,
block_dx=10,
block_y0=-10,
block_dy=5,
):
np.random.seed(1)
# Initiate I/O class for DC
IO = DC.IO()
# Obtain ABMN locations
xmin, xmax = 0.0, 200.0
ymin, ymax = 0.0, 0.0
zmin, zmax = 0, 0
endl = np.array([[xmin, ymin, zmin], [xmax, ymax, zmax]])
# Generate DC survey object
survey = DCutils.gen_DCIPsurvey(endl,
survey_type=survey_type,
dim=2,
a=10,
b=10,
n=10)
survey = IO.from_ambn_locations_to_survey(
survey.locations_a,
survey.locations_b,
survey.locations_m,
survey.locations_n,
survey_type,
data_dc_type="volt",
)
# Obtain 2D TensorMesh
mesh, actind = IO.set_mesh()
# Flat topography
actind = utils.surface2ind_topo(
mesh, np.c_[mesh.vectorCCx, mesh.vectorCCx * 0.0])
survey.drape_electrodes_on_topography(mesh, actind, option="top")
# Use Exponential Map: m = log(rho)
actmap = maps.InjectActiveCells(mesh,
indActive=actind,
valInactive=np.log(1e8))
parametric_block = maps.ParametricBlock(mesh, slopeFact=1e2)
mapping = maps.ExpMap(mesh) * parametric_block
# Set true model
# val_background,val_block, block_x0, block_dx, block_y0, block_dy
mtrue = np.r_[np.log(1e3), np.log(10), 100, 10, -20, 10]
# Set initial model
m0 = np.r_[np.log(rho_background),
np.log(rho_block), block_x0, block_dx, block_y0, block_dy, ]
rho = mapping * mtrue
rho0 = mapping * m0
# Show the true conductivity model
fig = plt.figure(figsize=(12, 3))
ax = plt.subplot(111)
temp = rho.copy()
temp[~actind] = np.nan
out = mesh.plotImage(
temp,
grid=False,
ax=ax,
gridOpts={"alpha": 0.2},
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
)
ax.plot(survey.electrode_locations[:, 0], survey.electrode_locations[:, 1],
"k.")
ax.set_xlim(IO.grids[:, 0].min(), IO.grids[:, 0].max())
ax.set_ylim(-IO.grids[:, 1].max(), IO.grids[:, 1].min())
cb = plt.colorbar(out[0])
cb.set_label("Resistivity (ohm-m)")
ax.set_aspect("equal")
ax.set_title("True resistivity model")
plt.show()
# Show the true conductivity model
fig = plt.figure(figsize=(12, 3))
ax = plt.subplot(111)
temp = rho0.copy()
temp[~actind] = np.nan
out = mesh.plotImage(
temp,
grid=False,
ax=ax,
gridOpts={"alpha": 0.2},
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
)
ax.plot(survey.electrode_locations[:, 0], survey.electrode_locations[:, 1],
"k.")
ax.set_xlim(IO.grids[:, 0].min(), IO.grids[:, 0].max())
ax.set_ylim(-IO.grids[:, 1].max(), IO.grids[:, 1].min())
cb = plt.colorbar(out[0])
cb.set_label("Resistivity (ohm-m)")
ax.set_aspect("equal")
ax.set_title("Initial resistivity model")
plt.show()
# Generate 2.5D DC problem
# "N" means potential is defined at nodes
prb = DC.Simulation2DNodal(mesh,
survey=survey,
rhoMap=mapping,
storeJ=True,
solver=Solver)
# Make synthetic DC data with 5% Gaussian noise
data = prb.make_synthetic_data(mtrue, relative_error=0.05, add_noise=True)
# Show apparent resisitivty pseudo-section
IO.plotPseudoSection(data=data.dobs / IO.G,
data_type="apparent_resistivity")
# Show apparent resisitivty histogram
fig = plt.figure()
out = hist(data.dobs / IO.G, bins=20)
plt.show()
# Set standard_deviation
# floor
eps = 10**(-3.2)
# percentage
relative = 0.05
dmisfit = data_misfit.L2DataMisfit(simulation=prb, data=data)
uncert = abs(data.dobs) * relative + eps
dmisfit.standard_deviation = uncert
# Map for a regularization
mesh_1d = discretize.TensorMesh([parametric_block.nP])
# Related to inversion
reg = regularization.Simple(mesh_1d, alpha_x=0.0)
opt = optimization.InexactGaussNewton(maxIter=10)
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
beta = directives.BetaSchedule(coolingFactor=5, coolingRate=2)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e0)
target = directives.TargetMisfit()
updateSensW = directives.UpdateSensitivityWeights()
update_Jacobi = directives.UpdatePreconditioner()
invProb.beta = 0.0
inv = inversion.BaseInversion(invProb, directiveList=[target])
prb.counter = opt.counter = utils.Counter()
opt.LSshorten = 0.5
opt.remember("xc")
# Run inversion
mopt = inv.run(m0)
# Convert obtained inversion model to resistivity
# rho = M(m), where M(.) is a mapping
rho_est = mapping * mopt
rho_true = rho.copy()
# show recovered conductivity
vmin, vmax = rho.min(), rho.max()
fig, ax = plt.subplots(2, 1, figsize=(20, 6))
out1 = mesh.plotImage(
rho_true,
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
ax=ax[0],
)
out2 = mesh.plotImage(
rho_est,
clim=(10, 1000),
pcolorOpts={
"cmap": "viridis",
"norm": colors.LogNorm()
},
ax=ax[1],
)
out = [out1, out2]
for i in range(2):
ax[i].plot(survey.electrode_locations[:, 0],
survey.electrode_locations[:, 1], "kv")
ax[i].set_xlim(IO.grids[:, 0].min(), IO.grids[:, 0].max())
ax[i].set_ylim(-IO.grids[:, 1].max(), IO.grids[:, 1].min())
cb = plt.colorbar(out[i][0], ax=ax[i])
cb.set_label("Resistivity ($\Omega$m)")
ax[i].set_xlabel("Northing (m)")
ax[i].set_ylabel("Elevation (m)")
ax[i].set_aspect("equal")
ax[0].set_title("True resistivity model")
ax[1].set_title("Recovered resistivity model")
plt.tight_layout()
plt.show()
def resolve_1Dinversions(
mesh,
dobs,
src_height,
freqs,
m0,
mref,
mapping,
relative=0.08,
floor=1e-14,
rxOffset=7.86,
):
"""
Perform a single 1D inversion for a RESOLVE sounding for Horizontal
Coplanar Coil data (both real and imaginary).
:param discretize.CylMesh mesh: mesh used for the forward simulation
:param numpy.ndarray dobs: observed data
:param float src_height: height of the source above the ground
:param numpy.ndarray freqs: frequencies
:param numpy.ndarray m0: starting model
:param numpy.ndarray mref: reference model
:param maps.IdentityMap mapping: mapping that maps the model to electrical conductivity
:param float relative: percent error used to construct the data misfit term
:param float floor: noise floor used to construct the data misfit term
:param float rxOffset: offset between source and receiver.
"""
# ------------------- Forward Simulation ------------------- #
# set up the receivers
bzr = FDEM.Rx.PointMagneticFluxDensitySecondary(np.array(
[[rxOffset, 0.0, src_height]]),
orientation="z",
component="real")
bzi = FDEM.Rx.PointMagneticFluxDensity(np.array(
[[rxOffset, 0.0, src_height]]),
orientation="z",
component="imag")
# source location
srcLoc = np.array([0.0, 0.0, src_height])
srcList = [
FDEM.Src.MagDipole([bzr, bzi], freq, srcLoc, orientation="Z")
for freq in freqs
]
# construct a forward simulation
survey = FDEM.Survey(srcList)
prb = FDEM.Simulation3DMagneticFluxDensity(mesh,
sigmaMap=mapping,
Solver=PardisoSolver)
prb.survey = survey
# ------------------- Inversion ------------------- #
# data misfit term
uncert = abs(dobs) * relative + floor
dat = data.Data(dobs=dobs, standard_deviation=uncert)
dmisfit = data_misfit.L2DataMisfit(simulation=prb, data=dat)
# regularization
regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
reg = regularization.Simple(regMesh)
reg.mref = mref
# optimization
opt = optimization.InexactGaussNewton(maxIter=10)
# statement of the inverse problem
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
# Inversion directives and parameters
target = directives.TargetMisfit()
inv = inversion.BaseInversion(invProb, directiveList=[target])
invProb.beta = 2.0 # Fix beta in the nonlinear iterations
reg.alpha_s = 1e-3
reg.alpha_x = 1.0
prb.counter = opt.counter = utils.Counter()
opt.LSshorten = 0.5
opt.remember("xc")
# run the inversion
mopt = inv.run(m0)
return mopt, invProb.dpred, survey.dobs
def run(plotIt=True):
cs, ncx, ncz, npad = 5.0, 25, 24, 15
hx = [(cs, ncx), (cs, npad, 1.3)]
hz = [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)]
mesh = discretize.CylMesh([hx, 1, hz], "00C")
active = mesh.vectorCCz < 0.0
layer = (mesh.vectorCCz < -50.0) & (mesh.vectorCCz >= -150.0)
actMap = maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
mapping = maps.ExpMap(mesh) * maps.SurjectVertical1D(mesh) * actMap
sig_half = 1e-3
sig_air = 1e-8
sig_layer = 1e-2
sigma = np.ones(mesh.nCz) * sig_air
sigma[active] = sig_half
sigma[layer] = sig_layer
mtrue = np.log(sigma[active])
x = np.r_[30, 50, 70, 90]
rxloc = np.c_[x, x * 0.0, np.zeros_like(x)]
prb = TDEM.Simulation3DMagneticFluxDensity(mesh,
sigmaMap=mapping,
solver=Solver)
prb.time_steps = [
(1e-3, 5),
(1e-4, 5),
(5e-5, 10),
(5e-5, 5),
(1e-4, 10),
(5e-4, 10),
]
# Use VTEM waveform
out = EMutils.VTEMFun(prb.times, 0.00595, 0.006, 100)
# Forming function handle for waveform using 1D linear interpolation
wavefun = interp1d(prb.times, out)
t0 = 0.006
waveform = TDEM.Src.RawWaveform(offTime=t0, waveFct=wavefun)
rx = TDEM.Rx.PointMagneticFluxTimeDerivative(
rxloc,
np.logspace(-4, -2.5, 11) + t0, "z")
src = TDEM.Src.CircularLoop([rx],
waveform=waveform,
loc=np.array([0.0, 0.0, 0.0]),
radius=10.0)
survey = TDEM.Survey([src])
prb.survey = survey
# create observed data
data = prb.make_synthetic_data(mtrue,
relative_error=0.02,
noise_floor=1e-11)
dmisfit = data_misfit.L2DataMisfit(simulation=prb, data=data)
regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
reg = regularization.Simple(regMesh)
opt = optimization.InexactGaussNewton(maxIter=5, LSshorten=0.5)
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
target = directives.TargetMisfit()
# Create an inversion object
beta = directives.BetaSchedule(coolingFactor=1.0, coolingRate=2.0)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e0)
invProb.beta = 1e2
inv = inversion.BaseInversion(invProb, directiveList=[beta, target])
m0 = np.log(np.ones(mtrue.size) * sig_half)
prb.counter = opt.counter = utils.Counter()
opt.remember("xc")
mopt = inv.run(m0)
if plotIt:
fig, ax = plt.subplots(1, 2, figsize=(10, 6))
Dobs = data.dobs.reshape((len(rx.times), len(x)))
Dpred = invProb.dpred.reshape((len(rx.times), len(x)))
for i in range(len(x)):
ax[0].loglog(rx.times - t0, -Dobs[:, i].flatten(), "k")
ax[0].loglog(rx.times - t0, -Dpred[:, i].flatten(), "k.")
if i == 0:
ax[0].legend(("$d^{obs}$", "$d^{pred}$"), fontsize=16)
ax[0].set_xlabel("Time (s)", fontsize=14)
ax[0].set_ylabel("$db_z / dt$ (nT/s)", fontsize=16)
ax[0].set_xlabel("Time (s)", fontsize=14)
ax[0].grid(color="k", alpha=0.5, linestyle="dashed", linewidth=0.5)
plt.semilogx(sigma[active], mesh.vectorCCz[active])
plt.semilogx(np.exp(mopt), mesh.vectorCCz[active])
ax[1].set_ylim(-600, 0)
ax[1].set_xlim(1e-4, 1e-1)
ax[1].set_xlabel("Conductivity (S/m)", fontsize=14)
ax[1].set_ylabel("Depth (m)", fontsize=14)
ax[1].grid(color="k", alpha=0.5, linestyle="dashed", linewidth=0.5)
plt.legend(["$\sigma_{true}$", "$\sigma_{pred}$"])
def run(plotIt=True):
cs, ncx, ncz, npad = 5.0, 25, 15, 15
hx = [(cs, ncx), (cs, npad, 1.3)]
hz = [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)]
mesh = discretize.CylMesh([hx, 1, hz], "00C")
active = mesh.vectorCCz < 0.0
layer = (mesh.vectorCCz < 0.0) & (mesh.vectorCCz >= -100.0)
actMap = maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
mapping = maps.ExpMap(mesh) * maps.SurjectVertical1D(mesh) * actMap
sig_half = 2e-3
sig_air = 1e-8
sig_layer = 1e-3
sigma = np.ones(mesh.nCz) * sig_air
sigma[active] = sig_half
sigma[layer] = sig_layer
mtrue = np.log(sigma[active])
rxOffset = 1e-3
rx = time_domain.Rx.PointMagneticFluxTimeDerivative(
np.array([[rxOffset, 0.0, 30]]), np.logspace(-5, -3, 31), "z"
)
src = time_domain.Src.MagDipole([rx], location=np.array([0.0, 0.0, 80]))
survey = time_domain.Survey([src])
time_steps = [(1e-06, 20), (1e-05, 20), (0.0001, 20)]
simulation = time_domain.Simulation3DElectricField(
mesh, sigmaMap=mapping, survey=survey, time_steps=time_steps
)
# d_true = simulation.dpred(mtrue)
# create observed data
rel_err = 0.05
data = simulation.make_synthetic_data(mtrue, relative_error=rel_err)
dmisfit = data_misfit.L2DataMisfit(simulation=simulation, data=data)
regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
reg = regularization.Tikhonov(regMesh, alpha_s=1e-2, alpha_x=1.0)
opt = optimization.InexactGaussNewton(maxIter=5, LSshorten=0.5)
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
# Create an inversion object
beta = directives.BetaSchedule(coolingFactor=5, coolingRate=2)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e0)
inv = inversion.BaseInversion(invProb, directiveList=[beta, betaest])
m0 = np.log(np.ones(mtrue.size) * sig_half)
simulation.counter = opt.counter = utils.Counter()
opt.remember("xc")
mopt = inv.run(m0)
if plotIt:
fig, ax = plt.subplots(1, 2, figsize=(10, 6))
ax[0].loglog(rx.times, -invProb.dpred, "b.-")
ax[0].loglog(rx.times, -data.dobs, "r.-")
ax[0].legend(("Noisefree", "$d^{obs}$"), fontsize=16)
ax[0].set_xlabel("Time (s)", fontsize=14)
ax[0].set_ylabel("$B_z$ (T)", fontsize=16)
ax[0].set_xlabel("Time (s)", fontsize=14)
ax[0].grid(color="k", alpha=0.5, linestyle="dashed", linewidth=0.5)
plt.semilogx(sigma[active], mesh.vectorCCz[active])
plt.semilogx(np.exp(mopt), mesh.vectorCCz[active])
ax[1].set_ylim(-600, 0)
ax[1].set_xlim(1e-4, 1e-2)
ax[1].set_xlabel("Conductivity (S/m)", fontsize=14)
ax[1].set_ylabel("Depth (m)", fontsize=14)
ax[1].grid(color="k", alpha=0.5, linestyle="dashed", linewidth=0.5)
plt.legend(["$\sigma_{true}$", "$\sigma_{pred}$"])
# Create reduced identity map
idenMap = maps.IdentityMap(nP=nC)
# Create a regularization
reg = regularization.Sparse(mesh, indActive=activeCells, mapping=idenMap)
m0 = np.ones(nC) * 1e-4 # Starting model
# Add directives to the inversion
opt = optimization.ProjectedGNCG(maxIter=100,
lower=-1.0,
upper=1.0,
maxIterLS=20,
maxIterCG=10,
tolCG=1e-3)
invProb = inverse_problem.BaseInvProblem(global_misfit, reg, opt)
betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e-1)
# Here is where the norms are applied
# Use a threshold parameter empirically based on the distribution of
# model parameters
update_IRLS = directives.Update_IRLS(
f_min_change=1e-4,
max_irls_iterations=0,
coolEpsFact=1.5,
beta_tol=1e-2,
)
saveDict = directives.SaveOutputEveryIteration(save_txt=False)
update_Jacobi = directives.UpdatePreconditioner()
sensitivity_weights = directives.UpdateSensitivityWeights(everyIter=False)
inv = inversion.BaseInversion(
# Create inverse problem
# Optimization
# set lower and upper bounds
lowerbound = np.r_[-2.0 * np.ones(actvMap.nP), 0.0 * np.ones(actvMap.nP)]
upperbound = np.r_[0.0 * np.ones(actvMap.nP), 1e-1 * np.ones(actvMap.nP)]
opt = optimization.ProjectedGNCG(
maxIter=30,
lower=lowerbound,
upper=upperbound,
maxIterLS=20,
maxIterCG=100,
tolCG=1e-4,
)
# create inverse problem
invProb = inverse_problem.BaseInvProblem(dmis, reg, opt)
inv = inversion.BaseInversion(
invProb,
# directives: evaluate alphas (and data misfits scales) before beta
directiveList=[
Alphas,
scaling_init,
beta,
update_smallness,
targets,
scale_schedule,
betaIt,
MrefInSmooth,
update_Jacobi,
],
)
def run(plotIt=True, saveFig=False, cleanup=True):
"""
Run 1D inversions for a single sounding of the RESOLVE and SkyTEM
bookpurnong data
:param bool plotIt: show the plots?
:param bool saveFig: save the figure
:param bool cleanup: remove the downloaded results
"""
downloads, directory = download_and_unzip_data()
resolve = h5py.File(os.path.sep.join([directory, "booky_resolve.hdf5"]),
"r")
skytem = h5py.File(os.path.sep.join([directory, "booky_skytem.hdf5"]), "r")
river_path = resolve["river_path"].value
# Choose a sounding location to invert
xloc, yloc = 462100.0, 6196500.0
rxind_skytem = np.argmin(
abs(skytem["xy"][:, 0] - xloc) + abs(skytem["xy"][:, 1] - yloc))
rxind_resolve = np.argmin(
abs(resolve["xy"][:, 0] - xloc) + abs(resolve["xy"][:, 1] - yloc))
# Plot both resolve and skytem data on 2D plane
fig = plt.figure(figsize=(13, 6))
title = ["RESOLVE In-phase 400 Hz", "SkyTEM High moment 156 $\mu$s"]
ax1 = plt.subplot(121)
ax2 = plt.subplot(122)
axs = [ax1, ax2]
out_re = utils.plot2Ddata(
resolve["xy"],
resolve["data"][:, 0],
ncontour=100,
contourOpts={"cmap": "viridis"},
ax=ax1,
)
vmin, vmax = out_re[0].get_clim()
cb_re = plt.colorbar(out_re[0],
ticks=np.linspace(vmin, vmax, 3),
ax=ax1,
fraction=0.046,
pad=0.04)
temp_skytem = skytem["data"][:, 5].copy()
temp_skytem[skytem["data"][:, 5] > 7e-10] = 7e-10
out_sky = utils.plot2Ddata(
skytem["xy"][:, :2],
temp_skytem,
ncontour=100,
contourOpts={
"cmap": "viridis",
"vmax": 7e-10
},
ax=ax2,
)
vmin, vmax = out_sky[0].get_clim()
cb_sky = plt.colorbar(
out_sky[0],
ticks=np.linspace(vmin, vmax * 0.99, 3),
ax=ax2,
format="%.1e",
fraction=0.046,
pad=0.04,
)
cb_re.set_label("Bz (ppm)")
cb_sky.set_label("dB$_z$ / dt (V/A-m$^4$)")
for i, ax in enumerate(axs):
xticks = [460000, 463000]
yticks = [6195000, 6198000, 6201000]
ax.set_xticks(xticks)
ax.set_yticks(yticks)
ax.plot(xloc, yloc, "wo")
ax.plot(river_path[:, 0], river_path[:, 1], "k", lw=0.5)
ax.set_aspect("equal")
if i == 1:
ax.plot(skytem["xy"][:, 0],
skytem["xy"][:, 1],
"k.",
alpha=0.02,
ms=1)
ax.set_yticklabels([str(" ") for f in yticks])
else:
ax.plot(resolve["xy"][:, 0],
resolve["xy"][:, 1],
"k.",
alpha=0.02,
ms=1)
ax.set_yticklabels([str(f) for f in yticks])
ax.set_ylabel("Northing (m)")
ax.set_xlabel("Easting (m)")
ax.set_title(title[i])
ax.axis("equal")
# plt.tight_layout()
if saveFig is True:
fig.savefig("resolve_skytem_data.png", dpi=600)
# ------------------ Mesh ------------------ #
# Step1: Set 2D cylindrical mesh
cs, ncx, ncz, npad = 1.0, 10.0, 10.0, 20
hx = [(cs, ncx), (cs, npad, 1.3)]
npad = 12
temp = np.logspace(np.log10(1.0), np.log10(12.0), 19)
temp_pad = temp[-1] * 1.3**np.arange(npad)
hz = np.r_[temp_pad[::-1], temp[::-1], temp, temp_pad]
mesh = discretize.CylMesh([hx, 1, hz], "00C")
active = mesh.vectorCCz < 0.0
# Step2: Set a SurjectVertical1D mapping
# Note: this sets our inversion model as 1D log conductivity
# below subsurface
active = mesh.vectorCCz < 0.0
actMap = maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
mapping = maps.ExpMap(mesh) * maps.SurjectVertical1D(mesh) * actMap
sig_half = 1e-1
sig_air = 1e-8
sigma = np.ones(mesh.nCz) * sig_air
sigma[active] = sig_half
# Initial and reference model
m0 = np.log(sigma[active])
# ------------------ RESOLVE Forward Simulation ------------------ #
# Step3: Invert Resolve data
# Bird height from the surface
b_height_resolve = resolve["src_elevation"].value
src_height_resolve = b_height_resolve[rxind_resolve]
# Set Rx (In-phase and Quadrature)
rxOffset = 7.86
bzr = FDEM.Rx.PointMagneticFluxDensitySecondary(
np.array([[rxOffset, 0.0, src_height_resolve]]),
orientation="z",
component="real",
)
bzi = FDEM.Rx.PointMagneticFluxDensity(
np.array([[rxOffset, 0.0, src_height_resolve]]),
orientation="z",
component="imag",
)
# Set Source (In-phase and Quadrature)
frequency_cp = resolve["frequency_cp"].value
freqs = frequency_cp.copy()
srcLoc = np.array([0.0, 0.0, src_height_resolve])
srcList = [
FDEM.Src.MagDipole([bzr, bzi], freq, srcLoc, orientation="Z")
for freq in freqs
]
# Set FDEM survey (In-phase and Quadrature)
survey = FDEM.Survey(srcList)
prb = FDEM.Simulation3DMagneticFluxDensity(mesh,
sigmaMap=mapping,
Solver=Solver)
prb.survey = survey
# ------------------ RESOLVE Inversion ------------------ #
# Primary field
bp = -mu_0 / (4 * np.pi * rxOffset**3)
# Observed data
cpi_inds = [0, 2, 6, 8, 10]
cpq_inds = [1, 3, 7, 9, 11]
dobs_re = (np.c_[resolve["data"][rxind_resolve, :][cpi_inds],
resolve["data"][rxind_resolve, :][cpq_inds], ].flatten() *
bp * 1e-6)
# Uncertainty
relative = np.repeat(np.r_[np.ones(3) * 0.1, np.ones(2) * 0.15], 2)
floor = 20 * abs(bp) * 1e-6
std = abs(dobs_re) * relative + floor
# Data Misfit
data_resolve = data.Data(dobs=dobs_re,
survey=survey,
standard_deviation=std)
dmisfit = data_misfit.L2DataMisfit(simulation=prb, data=data_resolve)
# Regularization
regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
reg = regularization.Simple(regMesh, mapping=maps.IdentityMap(regMesh))
# Optimization
opt = optimization.InexactGaussNewton(maxIter=5)
# statement of the inverse problem
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
# Inversion directives and parameters
target = directives.TargetMisfit() # stop when we hit target misfit
invProb.beta = 2.0
inv = inversion.BaseInversion(invProb, directiveList=[target])
reg.alpha_s = 1e-3
reg.alpha_x = 1.0
reg.mref = m0.copy()
opt.LSshorten = 0.5
opt.remember("xc")
# run the inversion
mopt_re = inv.run(m0)
dpred_re = invProb.dpred
# ------------------ SkyTEM Forward Simulation ------------------ #
# Step4: Invert SkyTEM data
# Bird height from the surface
b_height_skytem = skytem["src_elevation"].value
src_height = b_height_skytem[rxind_skytem]
srcLoc = np.array([0.0, 0.0, src_height])
# Radius of the source loop
area = skytem["area"].value
radius = np.sqrt(area / np.pi)
rxLoc = np.array([[radius, 0.0, src_height]])
# Parameters for current waveform
t0 = skytem["t0"].value
times = skytem["times"].value
waveform_skytem = skytem["waveform"].value
offTime = t0
times_off = times - t0
# Note: we are Using theoretical VTEM waveform,
# but effectively fits SkyTEM waveform
peakTime = 1.0000000e-02
a = 3.0
dbdt_z = TDEM.Rx.PointMagneticFluxTimeDerivative(
locations=rxLoc, times=times_off[:-3] + offTime,
orientation="z") # vertical db_dt
rxList = [dbdt_z] # list of receivers
srcList = [
TDEM.Src.CircularLoop(
rxList,
loc=srcLoc,
radius=radius,
orientation="z",
waveform=TDEM.Src.VTEMWaveform(offTime=offTime,
peakTime=peakTime,
a=3.0),
)
]
# solve the problem at these times
timeSteps = [
(peakTime / 5, 5),
((offTime - peakTime) / 5, 5),
(1e-5, 5),
(5e-5, 5),
(1e-4, 10),
(5e-4, 15),
]
prob = TDEM.Simulation3DElectricField(mesh,
time_steps=timeSteps,
sigmaMap=mapping,
Solver=Solver)
survey = TDEM.Survey(srcList)
prob.survey = survey
src = srcList[0]
rx = src.receiver_list[0]
wave = []
for time in prob.times:
wave.append(src.waveform.eval(time))
wave = np.hstack(wave)
out = prob.dpred(m0)
# plot the waveform
fig = plt.figure(figsize=(5, 3))
times_off = times - t0
plt.plot(waveform_skytem[:, 0], waveform_skytem[:, 1], "k.")
plt.plot(prob.times, wave, "k-", lw=2)
plt.legend(("SkyTEM waveform", "Waveform (fit)"), fontsize=10)
for t in rx.times:
plt.plot(np.ones(2) * t, np.r_[-0.03, 0.03], "k-")
plt.ylim(-0.1, 1.1)
plt.grid(True)
plt.xlabel("Time (s)")
plt.ylabel("Normalized current")
if saveFig:
fig.savefig("skytem_waveform", dpi=200)
# Observed data
dobs_sky = skytem["data"][rxind_skytem, :-3] * area
# ------------------ SkyTEM Inversion ------------------ #
# Uncertainty
relative = 0.12
floor = 7.5e-12
std = abs(dobs_sky) * relative + floor
# Data Misfit
data_sky = data.Data(dobs=-dobs_sky, survey=survey, standard_deviation=std)
dmisfit = data_misfit.L2DataMisfit(simulation=prob, data=data_sky)
# Regularization
regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
reg = regularization.Simple(regMesh, mapping=maps.IdentityMap(regMesh))
# Optimization
opt = optimization.InexactGaussNewton(maxIter=5)
# statement of the inverse problem
invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt)
# Directives and Inversion Parameters
target = directives.TargetMisfit()
invProb.beta = 20.0
inv = inversion.BaseInversion(invProb, directiveList=[target])
reg.alpha_s = 1e-1
reg.alpha_x = 1.0
opt.LSshorten = 0.5
opt.remember("xc")
reg.mref = mopt_re # Use RESOLVE model as a reference model
# run the inversion
mopt_sky = inv.run(m0)
dpred_sky = invProb.dpred
# Plot the figure from the paper
plt.figure(figsize=(12, 8))
fs = 13 # fontsize
matplotlib.rcParams["font.size"] = fs
ax0 = plt.subplot2grid((2, 2), (0, 0), rowspan=2)
ax1 = plt.subplot2grid((2, 2), (0, 1))
ax2 = plt.subplot2grid((2, 2), (1, 1))
# Recovered Models
sigma_re = np.repeat(np.exp(mopt_re), 2, axis=0)
sigma_sky = np.repeat(np.exp(mopt_sky), 2, axis=0)
z = np.repeat(mesh.vectorCCz[active][1:], 2, axis=0)
z = np.r_[mesh.vectorCCz[active][0], z, mesh.vectorCCz[active][-1]]
ax0.semilogx(sigma_re, z, "k", lw=2, label="RESOLVE")
ax0.semilogx(sigma_sky, z, "b", lw=2, label="SkyTEM")
ax0.set_ylim(-50, 0)
# ax0.set_xlim(5e-4, 1e2)
ax0.grid(True)
ax0.set_ylabel("Depth (m)")
ax0.set_xlabel("Conducivity (S/m)")
ax0.legend(loc=3)
ax0.set_title("(a) Recovered Models")
# RESOLVE Data
ax1.loglog(frequency_cp,
dobs_re.reshape((5, 2))[:, 0] / bp * 1e6,
"k-",
label="Obs (real)")
ax1.loglog(
frequency_cp,
dobs_re.reshape((5, 2))[:, 1] / bp * 1e6,
"k--",
label="Obs (imag)",
)
ax1.loglog(
frequency_cp,
dpred_re.reshape((5, 2))[:, 0] / bp * 1e6,
"k+",
ms=10,
markeredgewidth=2.0,
label="Pred (real)",
)
ax1.loglog(
frequency_cp,
dpred_re.reshape((5, 2))[:, 1] / bp * 1e6,
"ko",
ms=6,
markeredgecolor="k",
markeredgewidth=0.5,
label="Pred (imag)",
)
ax1.set_title("(b) RESOLVE")
ax1.set_xlabel("Frequency (Hz)")
ax1.set_ylabel("Bz (ppm)")
ax1.grid(True)
ax1.legend(loc=3, fontsize=11)
# SkyTEM data
ax2.loglog(times_off[3:] * 1e6, dobs_sky / area, "b-", label="Obs")
ax2.loglog(
times_off[3:] * 1e6,
-dpred_sky / area,
"bo",
ms=4,
markeredgecolor="k",
markeredgewidth=0.5,
label="Pred",
)
ax2.set_xlim(times_off.min() * 1e6 * 1.2, times_off.max() * 1e6 * 1.1)
ax2.set_xlabel("Time ($\mu s$)")
ax2.set_ylabel("dBz / dt (V/A-m$^4$)")
ax2.set_title("(c) SkyTEM High-moment")
ax2.grid(True)
ax2.legend(loc=3)
a3 = plt.axes([0.86, 0.33, 0.1, 0.09], facecolor=[0.8, 0.8, 0.8, 0.6])
a3.plot(prob.times * 1e6, wave, "k-")
a3.plot(rx.times * 1e6,
np.zeros_like(rx.times),
"k|",
markeredgewidth=1,
markersize=12)
a3.set_xlim([prob.times.min() * 1e6 * 0.75, prob.times.max() * 1e6 * 1.1])
a3.set_title("(d) Waveform", fontsize=11)
a3.set_xticks([prob.times.min() * 1e6, t0 * 1e6, prob.times.max() * 1e6])
a3.set_yticks([])
# a3.set_xticklabels(['0', '2e4'])
a3.set_xticklabels(["-1e4", "0", "1e4"])
plt.tight_layout()
if saveFig:
plt.savefig("booky1D_time_freq.png", dpi=600)
if plotIt:
plt.show()
resolve.close()
skytem.close()
if cleanup:
print(os.path.split(directory)[:-1])
os.remove(
os.path.sep.join(directory.split()[:-1] +
["._bookpurnong_inversion"]))
os.remove(downloads)
shutil.rmtree(directory)
