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 = InvProblem.BaseInvProblem(self.dmiscobmo, reg, opt)
directives = [
Directives.BetaEstimate_ByEig(beta0_ratio=1e-2),
]
inv = Inversion.BaseInversion(invProb, directiveList=directives)
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):
cs = 25.
hx = [(cs, 0, -1.3), (cs, 21), (cs, 0, 1.3)]
hz = [(cs, 0, -1.3), (cs, 20)]
mesh = Mesh.TensorMesh([hx, hz], x0="CN")
blkind0 = Utils.ModelBuilder.getIndicesSphere(np.r_[-100., -200.], 75.,
mesh.gridCC)
blkind1 = Utils.ModelBuilder.getIndicesSphere(np.r_[100., -200.], 75.,
mesh.gridCC)
sigma = np.ones(mesh.nC) * 1e-2
eta = np.zeros(mesh.nC)
tau = np.ones_like(sigma) * 1.
eta[blkind0] = 0.1
eta[blkind1] = 0.1
tau[blkind0] = 0.1
tau[blkind1] = 0.1
x = mesh.vectorCCx[(mesh.vectorCCx > -155.) & (mesh.vectorCCx < 155.)]
Aloc = np.r_[-200., 0.]
Bloc = np.r_[200., 0.]
M = Utils.ndgrid(x - 25., np.r_[0.])
N = Utils.ndgrid(x + 25., np.r_[0.])
times = np.arange(10) * 1e-3 + 1e-3
rx = SIP.Rx.Dipole(M, N, times)
src = SIP.Src.Dipole([rx], Aloc, Bloc)
survey = SIP.Survey([src])
wires = Maps.Wires(('eta', mesh.nC), ('taui', mesh.nC))
problem = SIP.Problem2D_CC(mesh,
rho=1. / sigma,
etaMap=wires.eta,
tauiMap=wires.taui,
verbose=False)
problem.Solver = Solver
problem.pair(survey)
mSynth = np.r_[eta, 1. / tau]
problem.model = mSynth
survey.makeSyntheticData(mSynth)
# Now set up the problem to do some minimization
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(mesh)
opt = Optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = InvProblem.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 MagneticsDiffSecondaryInv(mesh, model, data, **kwargs):
"""
Inversion module for MagneticsDiffSecondary
"""
from SimPEG import Optimization, Regularization, Parameters, ObjFunction, Inversion
prob = MagneticsDiffSecondary(mesh, model)
miter = kwargs.get('maxIter', 10)
if prob.ispaired:
prob.unpair()
if data.ispaired:
data.unpair()
prob.pair(data)
# Create an optimization program
opt = Optimization.InexactGaussNewton(maxIter=miter)
opt.bfgsH0 = Solver(sp.identity(model.nP), flag='D')
# Create a regularization program
reg = Regularization.Tikhonov(model)
# Create an objective function
beta = Parameters.BetaSchedule(beta0=1e0)
obj = ObjFunction.BaseObjFunction(data, reg, beta=beta)
# Create an inversion object
inv = Inversion.BaseInversion(obj, opt)
return inv, reg
def test_linked_properties(self):
mesh = Mesh.TensorMesh([8, 7, 6])
reg = Regularization.Tikhonov(mesh)
[self.assertTrue(reg.regmesh is fct.regmesh) for fct in reg.objfcts]
[self.assertTrue(reg.mapping is fct.mapping) for fct in reg.objfcts]
D = reg.regmesh.cellDiffx
reg.regmesh._cellDiffx = 4*D
v = np.random.rand(D.shape[1])
[
self.assertTrue(
np.all(reg.regmesh._cellDiffx*v == fct.regmesh.cellDiffx*v)
)
for fct in reg.objfcts
]
indActive = mesh.gridCC[:, 2] < 0.4
reg.indActive = indActive
self.assertTrue(np.all(reg.regmesh.indActive == indActive))
[
self.assertTrue(np.all(reg.indActive == fct.indActive))
for fct in reg.objfcts
]
[
self.assertTrue(np.all(reg.indActive == fct.regmesh.indActive))
for fct in reg.objfcts
]
def setUp(self, parallel=True):
frequency = np.array([900, 7200, 56000], dtype=float)
hz = get_vertical_discretization_frequency(
frequency, sigma_background=1./10.
)
n_sounding = 10
dx = 20.
hx = np.ones(n_sounding) * dx
mesh = Mesh.TensorMesh([hx, hz], x0='00')
inds = mesh.gridCC[:, 1] < 25
inds_1 = mesh.gridCC[:, 1] < 50
sigma = np.ones(mesh.nC) * 1./100.
sigma[inds_1] = 1./10.
sigma[inds] = 1./50.
sigma_em1d = sigma.reshape(mesh.vnC, order='F').flatten()
mSynth = np.log(sigma_em1d)
x = mesh.vectorCCx
y = np.zeros_like(x)
z = np.ones_like(x) * 30.
rx_locations = np.c_[x, y, z]
src_locations = np.c_[x, y, z]
topo = np.c_[x, y, z-30.].astype(float)
mapping = Maps.ExpMap(mesh)
survey = GlobalEM1DSurveyFD(
rx_locations=rx_locations,
src_locations=src_locations,
frequency=frequency,
offset=np.ones_like(frequency) * 8.,
src_type="VMD",
rx_type="Hz",
field_type='secondary',
topo=topo
)
problem = GlobalEM1DProblemFD(
[], sigmaMap=mapping, hz=hz,
parallel=parallel, n_cpu=5
)
problem.pair(survey)
survey.makeSyntheticData(mSynth)
# Now set up the problem to do some minimization
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(mesh)
opt = Optimization.InexactGaussNewton(
maxIterLS=20, maxIter=10, tolF=1e-6,
tolX=1e-6, tolG=1e-6, maxIterCG=6
)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=0.)
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 setUp(self, parallel=False):
frequency = np.array([900, 7200, 56000], dtype=float)
hz = np.r_[1.]
n_sounding = 10
dx = 20.
hx = np.ones(n_sounding) * dx
e = np.ones(n_sounding)
mSynth = np.r_[e * np.log(1. / 100.), e * 20]
x = np.arange(n_sounding)
y = np.zeros_like(x)
z = np.ones_like(x) * 30.
rx_locations = np.c_[x, y, z]
src_locations = np.c_[x, y, z]
topo = np.c_[x, y, z - 30.].astype(float)
wires = Maps.Wires(('sigma', n_sounding), ('h', n_sounding))
expmap = Maps.ExpMap(nP=n_sounding)
sigmaMap = expmap * wires.sigma
survey = GlobalEM1DSurveyFD(rx_locations=rx_locations,
src_locations=src_locations,
frequency=frequency,
offset=np.ones_like(frequency) * 8.,
src_type="VMD",
rx_type="ppm",
field_type='secondary',
topo=topo,
half_switch=True)
problem = GlobalEM1DProblemFD([],
sigmaMap=sigmaMap,
hMap=wires.h,
hz=hz,
parallel=parallel,
n_cpu=2)
problem.pair(survey)
survey.makeSyntheticData(mSynth)
# Now set up the problem to do some minimization
mesh = Mesh.TensorMesh([int(n_sounding * 2)])
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(mesh)
opt = Optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=0.)
inv = Inversion.BaseInversion(invProb)
self.inv = inv
self.reg = reg
self.p = problem
self.mesh = mesh
self.m0 = mSynth * 1.2
self.survey = survey
self.dmis = dmis
def run(N=100, plotIt=True):
np.random.seed(1)
mesh = Mesh.TensorMesh([N])
nk = 20
jk = np.linspace(1., 60., nk)
p = -0.25
q = 0.25
def g(k):
return (np.exp(p * jk[k] * mesh.vectorCCx) *
np.cos(np.pi * q * jk[k] * mesh.vectorCCx))
G = np.empty((nk, mesh.nC))
for i in range(nk):
G[i, :] = g(i)
mtrue = np.zeros(mesh.nC)
mtrue[mesh.vectorCCx > 0.3] = 1.
mtrue[mesh.vectorCCx > 0.45] = -0.5
mtrue[mesh.vectorCCx > 0.6] = 0
prob = Problem.LinearProblem(mesh, G=G)
survey = Survey.LinearSurvey()
survey.pair(prob)
survey.makeSyntheticData(mtrue, std=0.01)
M = prob.mesh
reg = Regularization.Tikhonov(mesh, alpha_s=1., alpha_x=1.)
dmis = DataMisfit.l2_DataMisfit(survey)
opt = Optimization.InexactGaussNewton(maxIter=60)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
directives = [
Directives.BetaEstimate_ByEig(beta0_ratio=1e-2),
Directives.TargetMisfit()
]
inv = Inversion.BaseInversion(invProb, directiveList=directives)
m0 = np.zeros_like(survey.mtrue)
mrec = inv.run(m0)
if plotIt:
fig, axes = plt.subplots(1, 2, figsize=(12 * 1.2, 4 * 1.2))
for i in range(prob.G.shape[0]):
axes[0].plot(prob.G[i, :])
axes[0].set_title('Columns of matrix G')
axes[1].plot(M.vectorCCx, survey.mtrue, 'b-')
axes[1].plot(M.vectorCCx, mrec, 'r-')
axes[1].legend(('True Model', 'Recovered Model'))
axes[1].set_ylim([-2, 2])
return prob, survey, mesh, mrec
def test_inv(self):
reg = Regularization.Tikhonov(self.mesh)
opt = Optimization.InexactGaussNewton(maxIter=10)
invProb = InvProblem.BaseInvProblem(self.dmiscobmo, reg, opt)
directives = [
Directives.BetaEstimate_ByEig(beta0_ratio=1e-2),
]
inv = Inversion.BaseInversion(invProb, directiveList=directives)
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 = Mesh.TensorMesh([hx, hy], x0="CN")
# x = np.linspace(-200, 200., 20)
x = np.linspace(-200, 200., 2)
M = Utils.ndgrid(x - 12.5, np.r_[0.])
N = Utils.ndgrid(x + 12.5, np.r_[0.])
A0loc = np.r_[-150, 0.]
A1loc = np.r_[-130, 0.]
B0loc = np.r_[-130, 0.]
B1loc = np.r_[-110, 0.]
rx = DC.Rx.Dipole_ky(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.
problem = IP.Problem2D_CC(mesh,
sigma=sigma,
etaMap=Maps.IdentityMap(mesh),
verbose=False)
problem.pair(survey)
mSynth = np.ones(mesh.nC) * 0.1
survey.makeSyntheticData(mSynth)
# Now set up the problem to do some minimization
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(mesh)
opt = Optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = InvProblem.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 run_inversion_direct(
self,
m0=0.0,
mref=0.0,
percentage=5,
floor=0.1,
chi_fact=1.0,
beta_min=1e-4,
beta_max=1e0,
n_beta=31,
alpha_s=1.0,
alpha_x=1.0,
):
survey, prob = self.get_problem_survey()
survey.eps = percentage
survey.std = floor
survey.dobs = self.data.copy()
self.uncertainty = percentage * abs(survey.dobs) * 0.01 + floor
m0 = np.ones(self.M) * m0
mref = np.ones(self.M) * mref
reg = Regularization.Tikhonov(self.mesh,
alpha_s=alpha_s,
alpha_x=alpha_x,
mref=mref)
dmis = DataMisfit.l2_DataMisfit(survey)
dmis.W = 1.0 / self.uncertainty
betas = np.logspace(np.log10(beta_min), np.log10(beta_max),
n_beta)[::-1]
phi_d = np.zeros(n_beta, dtype=float)
phi_m = np.zeros(n_beta, dtype=float)
models = []
preds = []
G = dmis.W.dot(self.G)
for ii, beta in enumerate(betas):
A = G.T.dot(G) + beta * reg.deriv2(m0)
b = -(dmis.deriv(m0) + beta * reg.deriv(m0))
m = np.linalg.solve(A, b)
phi_d[ii] = dmis(m) * 2.0
phi_m[ii] = reg(m) * 2.0
models.append(m)
preds.append(survey.dpred(m))
return phi_d, phi_m, models, preds, betas
def setUp(self):
aSpacing = 2.5
nElecs = 10
surveySize = nElecs * aSpacing - aSpacing
cs = surveySize / nElecs / 4
mesh = Mesh.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')
srcList = DC.Utils.WennerSrcList(nElecs, aSpacing, in2D=True)
survey = DC.Survey(srcList)
problem = DC.Problem3D_N(mesh,
rhoMap=Maps.IdentityMap(mesh),
storeJ=True)
problem.pair(survey)
mSynth = np.ones(mesh.nC)
survey.makeSyntheticData(mSynth)
# Now set up the problem to do some minimization
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(mesh)
opt = Optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = InvProblem.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 setUp(self):
cs = 12.5
hx = [(cs, 7, -1.3), (cs, 61), (cs, 7, 1.3)]
hy = [(cs, 7, -1.3), (cs, 20)]
mesh = Mesh.TensorMesh([hx, hy], x0="CN")
x = np.linspace(-135, 250., 20)
M = Utils.ndgrid(x - 12.5, np.r_[0.])
N = Utils.ndgrid(x + 12.5, np.r_[0.])
A0loc = np.r_[-150, 0.]
A1loc = np.r_[-130, 0.]
rxloc = [np.c_[M, np.zeros(20)], np.c_[N, np.zeros(20)]]
rx = DC.Rx.Dipole_ky(M, N)
src0 = DC.Src.Pole([rx], A0loc)
src1 = DC.Src.Pole([rx], A1loc)
survey = DC.Survey_ky([src0, src1])
problem = DC.Problem2D_N(mesh,
mapping=[('rho', Maps.IdentityMap(mesh))])
problem.pair(survey)
mSynth = np.ones(mesh.nC) * 1.
survey.makeSyntheticData(mSynth)
# Now set up the problem to do some minimization
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(mesh)
opt = Optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=1e0)
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_addition(self):
mesh = Mesh.TensorMesh([8, 7, 6])
m = np.random.rand(mesh.nC)
reg1 = Regularization.Tikhonov(mesh)
reg2 = Regularization.Simple(mesh)
reg_a = reg1 + reg2
self.assertTrue(len(reg_a)==2)
self.assertTrue(reg1(m) + reg2(m) == reg_a(m))
reg_a.test(eps=TOL)
reg_b = 2*reg1 + reg2
self.assertTrue(len(reg_b)==2)
self.assertTrue(2*reg1(m) + reg2(m) == reg_b(m))
reg_b.test(eps=TOL)
reg_c = reg1 + reg2/2
self.assertTrue(len(reg_c)==2)
self.assertTrue(reg1(m) + 0.5*reg2(m) == reg_c(m))
reg_c.test(eps=TOL)
def MagneticsDiffSecondaryInv(mesh, model, data, **kwargs):
"""
Inversion module for MagneticsDiffSecondary
"""
from SimPEG import Optimization, Regularization, Parameters, ObjFunction, Inversion
prob = Simulation3DDifferential(mesh, survey=data, mu=model)
miter = kwargs.get("maxIter", 10)
# Create an optimization program
opt = Optimization.InexactGaussNewton(maxIter=miter)
opt.bfgsH0 = Solver(sp.identity(model.nP), flag="D")
# Create a regularization program
reg = Regularization.Tikhonov(model)
# Create an objective function
beta = Parameters.BetaSchedule(beta0=1e0)
obj = ObjFunction.BaseObjFunction(prob, reg, beta=beta)
# Create an inversion object
inv = Inversion.BaseInversion(obj, opt)
return inv, reg
stop = clock()
print("timing of making synthetic data:", stop)
print("starting inversion of forward data")
# Tikhonov Inversion
####################
start = clock()
# Initial Model
m0 = np.median(ln_sigback) * np.ones(mapping.nP)
# Data Misfit
dmis = DataMisfit.l2_DataMisfit(survey)
uncert = abs(survey.dobs) * 0.05 * (10**(-3.2))
dmis.W = 1. / uncert
# Regularization
regT = Regularization.Tikhonov(mesh,
indActive=actinds,
alpha_s=1e-4,
alpha_x=1.,
alpha_y=1.,
alpha_z=1.)
# Optimization Scheme
opt = Optimization.InexactGaussNewton(maxIter=5)
# Form the problem
opt.remember('xc')
invProb = InvProblem.BaseInvProblem(dmis, regT, opt)
# Directives for Inversions
beta = Directives.BetaEstimate_ByEig(beta0_ratio=1e0)
Target = Directives.TargetMisfit()
betaSched = Directives.BetaSchedule(coolingFactor=5., coolingRate=2)
def run(plotIt=True):
cs, ncx, ncz, npad = 5., 25, 15, 15
hx = [(cs, ncx), (cs, npad, 1.3)]
hz = [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)]
mesh = Mesh.CylMesh([hx, 1, hz], '00C')
layerz = -100.
active = mesh.vectorCCz < 0.
layer = (mesh.vectorCCz < 0.) & (mesh.vectorCCz >= layerz)
actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz)
mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap
sig_half = 2e-2
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])
if plotIt:
fig, ax = plt.subplots(1, 1, figsize=(3, 6))
plt.semilogx(sigma[active], mesh.vectorCCz[active])
ax.set_ylim(-500, 0)
ax.set_xlim(1e-3, 1e-1)
ax.set_xlabel('Conductivity (S/m)', fontsize=14)
ax.set_ylabel('Depth (m)', fontsize=14)
ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
rxOffset = 10.
bzi = EM.FDEM.Rx.Point_b(np.array([[rxOffset, 0., 1e-3]]),
orientation='z',
component='imag')
freqs = np.logspace(1, 3, 10)
srcLoc = np.array([0., 0., 10.])
srcList = [
EM.FDEM.Src.MagDipole([bzi], freq, srcLoc, orientation='Z')
for freq in freqs
]
survey = EM.FDEM.Survey(srcList)
prb = EM.FDEM.Problem3D_b(mesh, sigmaMap=mapping, Solver=Solver)
prb.pair(survey)
std = 0.05
survey.makeSyntheticData(mtrue, std)
survey.std = std
survey.eps = np.linalg.norm(survey.dtrue) * 1e-5
if plotIt:
fig, ax = plt.subplots(1, 1, figsize=(6, 6))
ax.semilogx(freqs, survey.dtrue[:freqs.size], 'b.-')
ax.semilogx(freqs, survey.dobs[:freqs.size], 'r.-')
ax.legend(('Noisefree', '$d^{obs}$'), fontsize=16)
ax.set_xlabel('Time (s)', fontsize=14)
ax.set_ylabel('$B_z$ (T)', fontsize=16)
ax.set_xlabel('Time (s)', fontsize=14)
ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
dmisfit = DataMisfit.l2_DataMisfit(survey)
regMesh = Mesh.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
reg = Regularization.Tikhonov(regMesh)
opt = Optimization.InexactGaussNewton(maxIter=6)
invProb = InvProblem.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)
reg.alpha_s = 1e-3
reg.alpha_x = 1.
prb.counter = opt.counter = Utils.Counter()
opt.LSshorten = 0.5
opt.remember('xc')
mopt = inv.run(m0)
if plotIt:
fig, ax = plt.subplots(1, 1, figsize=(3, 6))
plt.semilogx(sigma[active], mesh.vectorCCz[active])
plt.semilogx(np.exp(mopt), mesh.vectorCCz[active])
ax.set_ylim(-500, 0)
ax.set_xlim(1e-3, 1e-1)
ax.set_xlabel('Conductivity (S/m)', fontsize=14)
ax.set_ylabel('Depth (m)', fontsize=14)
ax.grid(color='k', alpha=0.5, linestyle='dashed', linewidth=0.5)
plt.legend(['$\sigma_{true}$', '$\sigma_{pred}$'], loc='best')
def run(plotIt=True):
M = Mesh.TensorMesh([np.ones(40)], x0='N')
M.setCellGradBC('dirichlet')
# We will use the haverkamp empirical model with parameters from Celia1990
k_fun, theta_fun = Richards.Empirical.haverkamp(M,
A=1.1750e+06,
gamma=4.74,
alpha=1.6110e+06,
theta_s=0.287,
theta_r=0.075,
beta=3.96)
# Here we are making saturated hydraulic conductivity
# an exponential mapping to the model (defined below)
k_fun.KsMap = Maps.ExpMap(nP=M.nC)
# Setup the boundary and initial conditions
bc = np.array([-61.5, -20.7])
h = np.zeros(M.nC) + bc[0]
prob = Richards.RichardsProblem(M,
hydraulic_conductivity=k_fun,
water_retention=theta_fun,
boundary_conditions=bc,
initial_conditions=h,
do_newton=False,
method='mixed',
debug=False)
prob.timeSteps = [(5, 25, 1.1), (60, 40)]
# Create the survey
locs = -np.arange(2, 38, 4.)
times = np.arange(30, prob.timeMesh.vectorCCx[-1], 60)
rxSat = Richards.SaturationRx(locs, times)
survey = Richards.RichardsSurvey([rxSat])
survey.pair(prob)
# Create a simple model for Ks
Ks = 1e-3
mtrue = np.ones(M.nC) * np.log(Ks)
mtrue[15:20] = np.log(5e-2)
mtrue[20:35] = np.log(3e-3)
mtrue[35:40] = np.log(1e-2)
m0 = np.ones(M.nC) * np.log(Ks)
# Create some synthetic data and fields
stdev = 0.02 # The standard deviation for the noise
Hs = prob.fields(mtrue)
survey.makeSyntheticData(mtrue, std=stdev, f=Hs, force=True)
# Setup a pretty standard inversion
reg = Regularization.Tikhonov(M, alpha_s=1e-1)
dmis = DataMisfit.l2_DataMisfit(survey)
opt = Optimization.InexactGaussNewton(maxIter=20, maxIterCG=10)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
beta = Directives.BetaSchedule(coolingFactor=4)
betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1e2)
target = Directives.TargetMisfit()
dir_list = [beta, betaest, target]
inv = Inversion.BaseInversion(invProb, directiveList=dir_list)
mopt = inv.run(m0)
Hs_opt = prob.fields(mopt)
if plotIt:
plt.figure(figsize=(14, 9))
ax = plt.subplot(121)
plt.semilogx(np.exp(np.c_[mopt, mtrue]), M.gridCC)
plt.xlabel('Saturated Hydraulic Conductivity, $K_s$')
plt.ylabel('Depth, cm')
plt.semilogx([10**-3.9] * len(locs), locs, 'ro')
plt.legend(('$m_{rec}$', '$m_{true}$', 'Data locations'), loc=4)
ax = plt.subplot(222)
mesh2d = Mesh.TensorMesh([prob.timeMesh.hx / 60, prob.mesh.hx], '0N')
sats = [theta_fun(_) for _ in Hs]
clr = mesh2d.plotImage(np.c_[sats][1:, :], ax=ax)
cmap0 = matplotlib.cm.RdYlBu_r
clr[0].set_cmap(cmap0)
c = plt.colorbar(clr[0])
c.set_label('Saturation $\\theta$')
plt.xlabel('Time, minutes')
plt.ylabel('Depth, cm')
plt.title('True saturation over time')
ax = plt.subplot(224)
mesh2d = Mesh.TensorMesh([prob.timeMesh.hx / 60, prob.mesh.hx], '0N')
sats = [theta_fun(_) for _ in Hs_opt]
clr = mesh2d.plotImage(np.c_[sats][1:, :], ax=ax)
cmap0 = matplotlib.cm.RdYlBu_r
clr[0].set_cmap(cmap0)
c = plt.colorbar(clr[0])
c.set_label('Saturation $\\theta$')
plt.xlabel('Time, minutes')
plt.ylabel('Depth, cm')
plt.title('Recovered saturation over time')
plt.tight_layout()
def run(plotIt=True):
nC = 40
de = 1.
h = np.ones(nC) * de / nC
M = Mesh.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 = StraightRay.Rx(rlocs, None)
srcList = [
StraightRay.Src(loc=np.r_[M.vectorCCx[0], yi], rxList=[rx]) for yi in y
]
# phi model
phi0 = 0
phi1 = 0.65
phitrue = Utils.ModelBuilder.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., 1., 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 = StraightRay.Survey(srcList)
problem = StraightRay.Problem(M, slownessMap=slownessMap)
problem.pair(survey)
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
dobs = survey.makeSyntheticData(phitrue, std=0.03, force=True)
dpred = survey.dpred(np.zeros(M.nC))
# objective function pieces
reg = Regularization.Tikhonov(M)
dmis = DataMisfit.l2_DataMisfit(survey)
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 = InvProblem.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 = InvProblem.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(dobs)
ax.plot(dpred)
ax.plot(survey.dpred(mopt1), 'o')
ax.plot(survey.dpred(mopt2), 's')
ax.legend(['dobs', 'dpred0', 'dpred w/o Vol', 'dpred with Vol'])
fig, ax = plt.subplots(1, 3, figsize=(16, 4))
cb0 = plt.colorbar(M.plotImage(phitrue, ax=ax[0])[0], ax=ax[0])
cb1 = plt.colorbar(M.plotImage(mopt1, ax=ax[1])[0], ax=ax[1])
cb2 = plt.colorbar(M.plotImage(mopt2, ax=ax[2])[0], ax=ax[2])
for cb in [cb0, cb1, cb2]:
cb.set_clim([0., phi1])
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()
ax[0].set_title("Vertical section")
cb.set_label("Conductivity (S/m)")
ax[0].set_xlabel('Easting (m)')
ax[0].set_ylabel('Depth (m)')
ax[0].set_xlim(-1000., 1000.)
ax[0].set_ylim(-500., 0.)
###############################################################################
# Step 6
# ------
#
# Run inversion
regmesh = Mesh.TensorMesh([31])
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(regmesh)
opt = Optimization.InexactGaussNewton(maxIter=7, tolX=1e-15)
opt.remember('xc')
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
beta = Directives.BetaEstimate_ByEig(beta0_ratio=1e1)
betaSched = Directives.BetaSchedule(coolingFactor=5, coolingRate=2)
inv = Inversion.BaseInversion(invProb, directiveList=[beta, betaSched])
# Choose an initial starting model of the background conductivity
m0 = np.log(np.ones(mapping.nP) * sighalf)
mopt = inv.run(m0)
###############################################################################
# Step 7
# ------
#
)
sig0 = 1e-3
mref = np.log(sig0)*np.ones(actmap.nP)
m0 = mref.copy()
#sigma0 = np.ones(mesh_2d.nC) * 1e-3
#sigma0[blk1] = 1.
#m0 = np.log(sigma0[actind])
from SimPEG import (EM, Mesh, Maps, DataMisfit, Regularization,
Optimization, InvProblem, Inversion, Directives, Utils)
survey.dobs = dobs_dbdtz
survey.std = 0.05
survey.eps = 1e-14
dmisfit = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(
mesh_2d, alpha_s=1./mesh_2d.hx.min()**2, alpha_x=1., alpha_y=1.,
indActive=actind
)
opt = Optimization.InexactGaussNewton(maxIter=20, LSshorten=0.5)
opt.remember('xc')
invProb = InvProblem.BaseInvProblem(dmisfit, reg, opt)
# Create an inversion object
beta = Directives.BetaSchedule(coolingFactor=5, coolingRate=3)
betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1.)
target=Directives.TargetMisfit()
save_model = Directives.SaveModelEveryIteration()
save = Directives.SaveOutputEveryIteration()
inv = Inversion.BaseInversion(invProb, directiveList=[beta, betaest, target, save_model, save])
prb.counter = opt.counter = Utils.Counter()
reg.mref = mref
mopt = inv.run(m0)
def run_inversion(
m0, survey, actind, mesh,
std, eps,
maxIter=15, beta0_ratio=1e0,
coolingFactor=5, coolingRate=2,
upper=np.inf, lower=-np.inf,
use_sensitivity_weight=False,
alpha_s=1e-4,
alpha_x=1.,
alpha_y=1.,
alpha_z=1.,
):
"""
Run IP inversion
"""
dmisfit = DataMisfit.l2_DataMisfit(survey)
uncert = abs(survey.dobs) * std + eps
dmisfit.W = 1./uncert
# Map for a regularization
regmap = Maps.IdentityMap(nP=int(actind.sum()))
# Related to inversion
if use_sensitivity_weight:
reg = Regularization.Simple(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 = InvProblem.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
if use_sensitivity_weight:
updateSensW = Directives.UpdateSensitivityWeights()
update_Jacobi = Directives.UpdatePreconditioner()
directiveList = [
beta, betaest, target, updateSensW, update_Jacobi
]
else:
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=False):
O = np.r_[-1.2, -1.]
D = np.r_[10., 10.]
x = np.r_[0., 1.]
y = np.r_[0., 1.]
print('length:', StraightRay.lengthInCell(O, D, x, y, plotIt=plotIt))
O = np.r_[0, -1.]
D = np.r_[1., 1.] * 1.5
print('length:', StraightRay.lengthInCell(O,
D,
x * 2,
y * 2,
plotIt=plotIt))
nC = 20
M = Mesh.TensorMesh([nC, nC])
y = np.linspace(0., 1., nC / 2)
rlocs = np.c_[y * 0 + M.vectorCCx[-1], y]
rx = StraightRay.Rx(rlocs, None)
srcList = [
StraightRay.Src(loc=np.r_[M.vectorCCx[0], yi], rxList=[rx]) for yi in y
]
survey = StraightRay.Survey(srcList)
problem = StraightRay.Problem(M, slownessMap=Maps.IdentityMap(M))
problem.pair(survey)
s = Utils.mkvc(Utils.ModelBuilder.randomModel(M.vnC)) + 1.
survey.dobs = survey.dpred(s)
survey.std = 0.01
# Create an optimization program
reg = Regularization.Tikhonov(M)
dmis = DataMisfit.l2_DataMisfit(survey)
opt = Optimization.InexactGaussNewton(maxIter=40)
opt.remember('xc')
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
beta = Directives.BetaSchedule()
betaest = Directives.BetaEstimate_ByEig()
inv = Inversion.BaseInversion(invProb, directiveList=[beta, betaest])
# Start the inversion with a model of zeros, and run the inversion
m0 = np.ones(M.nC) * 1.5
mopt = inv.run(m0)
if plotIt is True:
fig, ax = plt.subplots(1, 2, figsize=(8, 4))
ax[1].plot(survey.dobs)
ax[1].plot(survey.dpred(m0), 's')
ax[1].plot(survey.dpred(mopt), 'o')
ax[1].legend(['dobs', 'starting dpred', 'dpred'])
M.plotImage(s, ax=ax[0])
survey.plot(ax=ax[0])
ax[0].set_title('survey')
plt.tight_layout()
if plotIt is True:
fig, ax = plt.subplots(1, 3, figsize=(12, 4))
plt.colorbar(M.plotImage(m0, ax=ax[0])[0], ax=ax[0])
plt.colorbar(M.plotImage(mopt, ax=ax[1])[0], ax=ax[1])
plt.colorbar(M.plotImage(s, ax=ax[2])[0], ax=ax[2])
ax[0].set_title('Starting Model')
ax[1].set_title('Recovered Model')
ax[2].set_title('True Model')
plt.tight_layout()
def run(plotIt=True):
"""
EM: TDEM: 1D: Inversion
=======================
Here we will create and run a TDEM 1D inversion.
"""
cs, ncx, ncz, npad = 5., 25, 15, 15
hx = [(cs, ncx), (cs, npad, 1.3)]
hz = [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)]
mesh = Mesh.CylMesh([hx, 1, hz], '00C')
active = mesh.vectorCCz < 0.
layer = (mesh.vectorCCz < 0.) & (mesh.vectorCCz >= -100.)
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 = EM.TDEM.Rx.Point_b(np.array([[rxOffset, 0., 30]]),
np.logspace(-5, -3, 31), 'z')
src = EM.TDEM.Src.MagDipole([rx], loc=np.array([0., 0., 80]))
survey = EM.TDEM.Survey([src])
prb = EM.TDEM.Problem3D_b(mesh, sigmaMap=mapping)
prb.Solver = SolverLU
prb.timeSteps = [(1e-06, 20), (1e-05, 20), (0.0001, 20)]
prb.pair(survey)
# create observed data
std = 0.05
survey.dobs = survey.makeSyntheticData(mtrue, std)
survey.std = std
survey.eps = 1e-5 * np.linalg.norm(survey.dobs)
dmisfit = DataMisfit.l2_DataMisfit(survey)
regMesh = Mesh.TensorMesh([mesh.hz[mapping.maps[-1].indActive]])
reg = Regularization.Tikhonov(regMesh, alpha_s=1e-2, alpha_x=1.)
opt = Optimization.InexactGaussNewton(maxIter=5, LSshorten=0.5)
invProb = InvProblem.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)
prb.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, survey.dtrue, 'b.-')
ax[0].loglog(rx.times, survey.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}$'])
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.,
c_lower=1e-2,
c_upper=1.,
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 = DataMisfit.l2_DataMisfit(survey)
uncert = abs(survey.dobs) * std + eps
dmisfit.W = 1. / 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.Tikhonov(mesh,
mapping=wires.eta,
indActive=actind)
reg_tau = Regularization.Tikhonov(mesh,
mapping=wires.tau,
indActive=actind)
reg_c = Regularization.Tikhonov(mesh, mapping=wires.c, indActive=actind)
# Todo:
reg_eta.alpha_s = alpha_s
reg_tau.alpha_s = alpha_s
reg_c.alpha_s = alpha_s
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 = InvProblem.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
rxLoc = survey.srcField.rxList[0].locs
wr = np.zeros(prob.F.shape[1])
for ii in range(survey.nD):
wr += (prob.F[ii, :]/survey.std[ii])**2.
wr /= mesh.vol[actv]
wr = (wr/np.max(wr))
wr = wr**0.5
Mesh.TreeMesh.writeUBC(mesh, work_dir + out_dir + 'OctreeTest.msh',
models={work_dir + out_dir + 'SensWeights.sus': actvMap*wr})
# wr = PF.Magnetics.get_dist_wgt(mesh, rxLoc, actv, 3, 1)
# Create a regularization
reg = Regularization.Tikhonov(mesh, indActive=actv, mapping=idenMap)
# reg.norms = driver.lpnorms
# # reg.alpha_s = 2.5e-3
# if driver.eps is not None:
# reg.eps_p = driver.eps[0]
# reg.eps_q = driver.eps[1]
reg.cell_weights = wr#driver.cell_weights*mesh.vol**0.5
reg.mref = np.zeros(nC)
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey)
dmis.W = 1./survey.std
# Add directives to the inversion
opt = Optimization.ProjectedGNCG(maxIter=20, lower=0., upper=10.,
maxIterLS=20, maxIterCG=10,
mapping = Maps.ExpMap(mesh)
survey = DC.Survey(srclist)
problem = DC.Problem3D_CC(mesh, sigmaMap=mapping)
problem.pair(survey)
problem.Solver = PardisoSolver
survey.dpred(mtrue)
survey.makeSyntheticData(mtrue, std=0.05, force=True)
print '# of data: ', survey.dobs.shape
#Simple Inversion
regmesh = mesh
m0 = (-5.) * np.ones(mapping.nP)
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(regmesh) #,mapping = mapping)#,indActive=actind)
reg.mref = m0
opt = Optimization.InexactGaussNewton(maxIter=20, tolX=1e-6)
opt.remember('xc')
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
beta = Directives.BetaEstimate_ByEig(beta0=10., beta0_ratio=1e0)
reg.alpha_s = 1e-2
#beta = 0.
#invProb.beta = beta
betaSched = Directives.BetaSchedule(coolingFactor=5, coolingRate=2)
#sav0 = Directives.SaveEveryIteration()
#sav1 = Directives.SaveModelEveryIteration()
sav2 = Directives.SaveOutputDictEveryIteration()
inv = Inversion.BaseInversion(invProb, directiveList=[sav2, beta,
betaSched]) #sav0,sav1,
def run_inversion(
self,
maxIter=60,
m0=0.0,
mref=0.0,
percentage=5,
floor=0.1,
chifact=1,
beta0_ratio=1.0,
coolingFactor=1,
n_iter_per_beta=1,
alpha_s=1.0,
alpha_x=1.0,
alpha_z=1.0,
use_target=False,
use_tikhonov=True,
use_irls=False,
p_s=2,
p_x=2,
p_y=2,
p_z=2,
beta_start=None,
):
self.uncertainty = percentage * abs(self.survey.dobs) * 0.01 + floor
m0 = np.ones(self.mesh.nC) * m0
mref = np.ones(self.mesh.nC) * mref
if ~use_tikhonov:
reg = Regularization.Sparse(
self.mesh,
alpha_s=alpha_s,
alpha_x=alpha_x,
alpha_y=alpha_z,
mref=mref,
mapping=Maps.IdentityMap(self.mesh),
cell_weights=self.mesh.vol,
)
else:
reg = Regularization.Tikhonov(
self.mesh,
alpha_s=alpha_s,
alpha_x=alpha_x,
alpha_y=alpha_z,
mref=mref,
mapping=Maps.IdentityMap(self.mesh),
)
dmis = DataMisfit.l2_DataMisfit(self.survey)
dmis.W = 1.0 / self.uncertainty
opt = Optimization.ProjectedGNCG(maxIter=maxIter, maxIterCG=20)
opt.lower = 0.0
opt.remember("xc")
opt.tolG = 1e-10
opt.eps = 1e-10
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
save = Directives.SaveOutputEveryIteration()
beta_schedule = Directives.BetaSchedule(coolingFactor=coolingFactor,
coolingRate=n_iter_per_beta)
if use_irls:
IRLS = Directives.Update_IRLS(
f_min_change=1e-4,
minGNiter=1,
silent=False,
maxIRLSiter=40,
beta_tol=5e-1,
coolEpsFact=1.3,
chifact_start=chifact,
)
if beta_start is None:
directives = [
Directives.BetaEstimate_ByEig(beta0_ratio=beta0_ratio),
IRLS,
save,
]
else:
directives = [IRLS, save]
invProb.beta = beta_start
reg.norms = np.c_[p_s, p_x, p_z, 2]
else:
target = Directives.TargetMisfit(chifact=chifact)
directives = [
Directives.BetaEstimate_ByEig(beta0_ratio=beta0_ratio),
beta_schedule,
save,
]
if use_target:
directives.append(target)
inv = Inversion.BaseInversion(invProb, directiveList=directives)
mopt = inv.run(m0)
model = opt.recall("xc")
model.append(mopt)
pred = []
for m in model:
pred.append(self.survey.dpred(m))
return model, pred, save
def setUp(self, parallel=True):
time = np.logspace(-6, -3, 21)
hz = get_vertical_discretization_time(time,
facter_tmax=0.5,
factor_tmin=10.)
time_input_currents = wave.current_times[-7:]
input_currents = wave.currents[-7:]
n_sounding = 10
dx = 20.
hx = np.ones(n_sounding) * dx
mesh = Mesh.TensorMesh([hx, hz], x0='00')
inds = mesh.gridCC[:, 1] < 25
inds_1 = mesh.gridCC[:, 1] < 50
sigma = np.ones(mesh.nC) * 1. / 100.
sigma[inds_1] = 1. / 10.
sigma[inds] = 1. / 50.
sigma_em1d = sigma.reshape(mesh.vnC, order='F').flatten()
mSynth = np.log(sigma_em1d)
x = mesh.vectorCCx
y = np.zeros_like(x)
z = np.ones_like(x) * 30.
rx_locations = np.c_[x, y, z]
src_locations = np.c_[x, y, z]
topo = np.c_[x, y, z - 30.].astype(float)
n_sounding = rx_locations.shape[0]
rx_type_global = np.array(["dBzdt"], dtype=str).repeat(n_sounding,
axis=0)
field_type_global = np.array(['secondary'],
dtype=str).repeat(n_sounding, axis=0)
wave_type_global = np.array(['general'], dtype=str).repeat(n_sounding,
axis=0)
time_global = [time for i in range(n_sounding)]
src_type_global = np.array(["CircularLoop"],
dtype=str).repeat(n_sounding, axis=0)
a_global = np.array([13.], dtype=float).repeat(n_sounding, axis=0)
input_currents_global = [input_currents for i in range(n_sounding)]
time_input_currents_global = [
time_input_currents for i in range(n_sounding)
]
mapping = Maps.ExpMap(mesh)
survey = GlobalEM1DSurveyTD(
rx_locations=rx_locations,
src_locations=src_locations,
topo=topo,
time=time_global,
src_type=src_type_global,
rx_type=rx_type_global,
field_type=field_type_global,
wave_type=wave_type_global,
a=a_global,
input_currents=input_currents_global,
time_input_currents=time_input_currents_global)
problem = GlobalEM1DProblemTD(mesh,
sigmaMap=mapping,
hz=hz,
parallel=parallel,
n_cpu=5)
problem.pair(survey)
survey.makeSyntheticData(mSynth)
# Now set up the problem to do some minimization
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Tikhonov(mesh)
opt = Optimization.InexactGaussNewton(maxIterLS=20,
maxIter=10,
tolF=1e-6,
tolX=1e-6,
tolG=1e-6,
maxIterCG=6)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt, beta=0.)
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 run_inversion_cg(
self,
maxIter=60,
m0=0.0,
mref=0.0,
percentage=5,
floor=0.1,
chifact=1,
beta0_ratio=1.0,
coolingFactor=1,
coolingRate=1,
alpha_s=1.0,
alpha_x=1.0,
use_target=False,
):
survey, prob = self.get_problem_survey()
survey.eps = percentage
survey.std = floor
survey.dobs = self.data.copy()
self.uncertainty = percentage * abs(survey.dobs) * 0.01 + floor
m0 = np.ones(self.M) * m0
mref = np.ones(self.M) * mref
reg = Regularization.Tikhonov(
self.mesh, alpha_s=alpha_s, alpha_x=alpha_x, mref=mref
)
dmis = DataMisfit.l2_DataMisfit(survey)
dmis.W = 1.0 / self.uncertainty
opt = Optimization.InexactGaussNewton(maxIter=maxIter, maxIterCG=20)
opt.remember("xc")
opt.tolG = 1e-10
opt.eps = 1e-10
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
save = Directives.SaveOutputEveryIteration()
beta_schedule = Directives.BetaSchedule(
coolingFactor=coolingFactor, coolingRate=coolingRate
)
target = Directives.TargetMisfit(chifact=chifact)
if use_target:
directives = [
Directives.BetaEstimate_ByEig(beta0_ratio=beta0_ratio),
beta_schedule,
target,
save,
]
else:
directives = [
Directives.BetaEstimate_ByEig(beta0_ratio=beta0_ratio),
beta_schedule,
save,
]
inv = Inversion.BaseInversion(invProb, directiveList=directives)
mopt = inv.run(m0)
model = opt.recall("xc")
model.append(mopt)
pred = []
for m in model:
pred.append(survey.dpred(m))
return model, pred, save
def run(plotIt=True):
"""
FLOW: Richards: 1D: Inversion
=============================
The example shows an inversion of Richards equation in 1D with a
heterogeneous hydraulic conductivity function.
The haverkamp model is used with the same parameters as Celia1990_
the boundary and initial conditions are also the same. The simulation
domain is 40cm deep and is run for an hour with an exponentially
increasing time step that has a maximum of one minute. The general
setup of the experiment is an infiltration front that advances
downward through the model over time.
The model chosen is the saturated hydraulic conductivity inside
the hydraulic conductivity function (using haverkamp). The initial
model is chosen to be the background (1e-3 cm/s). The saturation data
has 2% random Gaussian noise added.
The figure shows the recovered saturated hydraulic conductivity
next to the true model. The other two figures show the saturation
field for the entire simulation for the true and recovered models.
Rowan Cockett - 21/12/2016
.. _Celia1990: http://www.webpages.uidaho.edu/ch/papers/Celia.pdf
"""
M = Mesh.TensorMesh([np.ones(40)], x0='N')
M.setCellGradBC('dirichlet')
# We will use the haverkamp empirical model with parameters from Celia1990
k_fun, theta_fun = Richards.Empirical.haverkamp(M,
A=1.1750e+06,
gamma=4.74,
alpha=1.6110e+06,
theta_s=0.287,
theta_r=0.075,
beta=3.96)
# Here we are making saturated hydraulic conductivity
# an exponential mapping to the model (defined below)
k_fun.KsMap = Maps.ExpMap(nP=M.nC)
# Setup the boundary and initial conditions
bc = np.array([-61.5, -20.7])
h = np.zeros(M.nC) + bc[0]
prob = Richards.RichardsProblem(M,
hydraulic_conductivity=k_fun,
water_retention=theta_fun,
boundary_conditions=bc,
initial_conditions=h,
do_newton=False,
method='mixed',
debug=False)
prob.timeSteps = [(5, 25, 1.1), (60, 40)]
# Create the survey
locs = -np.arange(2, 38, 4.)
times = np.arange(30, prob.timeMesh.vectorCCx[-1], 60)
rxSat = Richards.SaturationRx(locs, times)
survey = Richards.RichardsSurvey([rxSat])
survey.pair(prob)
# Create a simple model for Ks
Ks = 1e-3
mtrue = np.ones(M.nC) * np.log(Ks)
mtrue[15:20] = np.log(5e-2)
mtrue[20:35] = np.log(3e-3)
mtrue[35:40] = np.log(1e-2)
m0 = np.ones(M.nC) * np.log(Ks)
# Create some synthetic data and fields
stdev = 0.02 # The standard deviation for the noise
Hs = prob.fields(mtrue)
survey.makeSyntheticData(mtrue, std=stdev, f=Hs, force=True)
# Setup a pretty standard inversion
reg = Regularization.Tikhonov(M, alpha_s=1e-1)
dmis = DataMisfit.l2_DataMisfit(survey)
opt = Optimization.InexactGaussNewton(maxIter=20, maxIterCG=10)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
beta = Directives.BetaSchedule(coolingFactor=4)
betaest = Directives.BetaEstimate_ByEig(beta0_ratio=1e2)
target = Directives.TargetMisfit()
dir_list = [beta, betaest, target]
inv = Inversion.BaseInversion(invProb, directiveList=dir_list)
mopt = inv.run(m0)
Hs_opt = prob.fields(mopt)
if plotIt:
plt.figure(figsize=(14, 9))
ax = plt.subplot(121)
plt.semilogx(np.exp(np.c_[mopt, mtrue]), M.gridCC)
plt.xlabel('Saturated Hydraulic Conductivity, $K_s$')
plt.ylabel('Depth, cm')
plt.semilogx([10**-3.9] * len(locs), locs, 'ro')
plt.legend(('$m_{rec}$', '$m_{true}$', 'Data locations'), loc=4)
ax = plt.subplot(222)
mesh2d = Mesh.TensorMesh([prob.timeMesh.hx / 60, prob.mesh.hx], '0N')
sats = [theta_fun(_) for _ in Hs]
clr = mesh2d.plotImage(np.c_[sats][1:, :], ax=ax)
cmap0 = matplotlib.cm.RdYlBu_r
clr[0].set_cmap(cmap0)
c = plt.colorbar(clr[0])
c.set_label('Saturation $\\theta$')
plt.xlabel('Time, minutes')
plt.ylabel('Depth, cm')
plt.title('True saturation over time')
ax = plt.subplot(224)
mesh2d = Mesh.TensorMesh([prob.timeMesh.hx / 60, prob.mesh.hx], '0N')
sats = [theta_fun(_) for _ in Hs_opt]
clr = mesh2d.plotImage(np.c_[sats][1:, :], ax=ax)
cmap0 = matplotlib.cm.RdYlBu_r
clr[0].set_cmap(cmap0)
c = plt.colorbar(clr[0])
c.set_label('Saturation $\\theta$')
plt.xlabel('Time, minutes')
plt.ylabel('Depth, cm')
plt.title('Recovered saturation over time')
plt.tight_layout()
