def setUp(self):
cs = 25.
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 = Mesh.TensorMesh([hx, hy, hz], x0="CCN")
blkind0 = Utils.ModelBuilder.getIndicesSphere(
np.r_[-100., -100., -200.], 75., mesh.gridCC
)
blkind1 = Utils.ModelBuilder.getIndicesSphere(
np.r_[100., 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.01
x = mesh.vectorCCx[(mesh.vectorCCx > -155.) & (mesh.vectorCCx < 155.)]
y = mesh.vectorCCx[(mesh.vectorCCy > -155.) & (mesh.vectorCCy < 155.)]
Aloc = np.r_[-200., 0., 0.]
Bloc = np.r_[200., 0., 0.]
M = Utils.ndgrid(x-25., y, np.r_[0.])
N = Utils.ndgrid(x+25., y, 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.Problem3D_N(
mesh,
sigma=sigma,
etaMap=wires.eta,
tauiMap=wires.taui
)
problem.Solver = Solver
problem.pair(survey)
mSynth = np.r_[eta, 1./tau]
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 test_basic_inversion(self):
"""
Test to see if inversion recovers model
"""
h = [(2, 30)]
meshObj = Mesh.TensorMesh((h, h, [(2, 10)]), x0='CCN')
mod = 0.00025 * np.ones(meshObj.nC)
mod[(meshObj.gridCC[:, 0] > -4.) & (meshObj.gridCC[:, 1] > -4.) &
(meshObj.gridCC[:, 0] < 4.) & (meshObj.gridCC[:, 1] < 4.)] = 0.001
times = np.logspace(-4, -2, 5)
waveObj = VRM.WaveformVRM.SquarePulse(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))
rxList = [VRM.Rx.Point(np.c_[x, y, z], times, 'dbdt', '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(rxList, txNodes, 1., waveObj)]
Survey = VRM.Survey(txList)
Problem = VRM.Problem_Linear(meshObj, refFact=2)
Problem.pair(Survey)
Survey.makeSyntheticData(mod)
Survey.eps = 1e-11
dmis = DataMisfit.l2_DataMisfit(Survey)
W = mkvc((np.sum(np.array(Problem.A)**2, axis=0)))**0.25
reg = Regularization.Simple(meshObj,
alpha_s=0.01,
alpha_x=1.,
alpha_y=1.,
alpha_z=1.,
cell_weights=W)
opt = Optimization.ProjectedGNCG(maxIter=20,
lower=0.,
upper=1e-2,
maxIterLS=20,
tolCG=1e-4)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
directives = [
Directives.BetaSchedule(coolingFactor=2, coolingRate=1),
Directives.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() * (Survey.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 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_GN_quadratic(self):
GN = Optimization.GaussNewton()
xopt = GN.minimize(getQuadratic(self.A, self.b), np.array([0, 0]))
x_true = np.array([5., 5.])
print('xopt: ', xopt)
print('x_true: ', x_true)
self.assertTrue(np.linalg.norm(xopt - x_true, 2) < TOL, True)
def test_GN_Rosenbrock(self):
GN = Optimization.GaussNewton()
xopt = GN.minimize(Rosenbrock, np.array([0, 0]))
x_true = np.array([1., 1.])
print('xopt: ', xopt)
print('x_true: ', x_true)
self.assertTrue(np.linalg.norm(xopt - x_true, 2) < TOL, True)
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 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 test_ProjGradient_quadraticBounded(self):
PG = Optimization.ProjectedGradient(debug=True)
PG.lower, PG.upper = -2, 2
xopt = PG.minimize(getQuadratic(self.A, self.b), np.array([0, 0]))
x_true = np.array([2., 2.])
print('xopt: ', xopt)
print('x_true: ', x_true)
self.assertTrue(np.linalg.norm(xopt - x_true, 2) < TOL, True)
def test_NewtonRoot(self):
fun = lambda x, return_g=True: np.sin(x) if not return_g else ( np.sin(x), sdiag( np.cos(x) ) )
x = np.array([np.pi-0.3, np.pi+0.1, 0])
xopt = Optimization.NewtonRoot(comments=False).root(fun,x)
x_true = np.array([np.pi,np.pi,0])
print('Newton Root Finding')
print('xopt: ', xopt)
print('x_true: ', x_true)
self.assertTrue(np.linalg.norm(xopt-x_true,2) < TOL, True)
def rootFinder(self):
"""Root-finding Algorithm"""
if getattr(self, '_rootFinder', None) is None:
self._rootFinder = Optimization.NewtonRoot(
doLS=self.doNewton,
maxIter=self.maxIterRootFinder,
tol=self.tolRootFinder,
Solver=self.Solver)
return self._rootFinder
def test_ProjGradient_quadratic1Bound(self):
myB = np.array([-5, 1])
PG = Optimization.ProjectedGradient()
PG.lower, PG.upper = -2, 2
xopt = PG.minimize(getQuadratic(self.A, myB), np.array([0, 0]))
x_true = np.array([2., -1.])
print('xopt: ', xopt)
print('x_true: ', x_true)
self.assertTrue(np.linalg.norm(xopt - x_true, 2) < TOL, True)
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 fit_colecole_with_se(self, eta_cc=0.8, tau_cc=0.003, c_cc=0.6):
def ColeColeSeigel(f, sigmaInf, eta, tau, c):
w = 2 * np.pi * f
return sigmaInf * (1 - eta / (1 + (1j * w * tau)**c))
# Step1: Fit Cole-Cole with Stretched Exponential function
time = np.logspace(-6, np.log10(0.01), 41)
wt, tbase, omega_int = DigFilter.setFrequency(time)
frequency = omega_int / (2 * np.pi)
# Cole-Cole parameters
siginf = 1.
self.eta_cc = eta_cc
self.tau_cc = tau_cc
self.c_cc = c_cc
sigma = ColeColeSeigel(frequency, siginf, eta_cc, tau_cc, c_cc)
sigTCole = DigFilter.transFiltImpulse(sigma,
wt,
tbase,
omega_int,
time,
tol=1e-12)
wires = Maps.Wires(('eta', 1), ('tau', 1), ('c', 1))
taumap = Maps.ExpMap(nP=1) * wires.tau
survey = SESurvey()
dtrue = -sigTCole
survey.dobs = dtrue
m1D = Mesh.TensorMesh([np.ones(3)])
prob = SEInvImpulseProblem(m1D,
etaMap=wires.eta,
tauMap=taumap,
cMap=wires.c)
update_sens = Directives.UpdateSensitivityWeights()
prob.time = time
prob.pair(survey)
m0 = np.r_[eta_cc, np.log(tau_cc), c_cc]
perc = 0.05
dmisfitpeta = DataMisfit.l2_DataMisfit(survey)
dmisfitpeta.W = 1 / (abs(survey.dobs) * perc)
reg = regularization.Simple(m1D)
opt = Optimization.ProjectedGNCG(maxIter=10)
invProb = InvProblem.BaseInvProblem(dmisfitpeta, reg, opt)
# Create an inversion object
target = Directives.TargetMisfit()
invProb.beta = 0.
inv = Inversion.BaseInversion(invProb, directiveList=[target])
reg.mref = 0. * m0
prob.counter = opt.counter = Utils.Counter()
opt.LSshorten = 0.5
opt.remember('xc')
opt.tolX = 1e-20
opt.tolF = 1e-20
opt.tolG = 1e-20
opt.eps = 1e-20
mopt = inv.run(m0)
return mopt
def root_finder(self):
"""Root-finding Algorithm"""
if getattr(self, '_root_finder', None) is None:
self._root_finder = Optimization.NewtonRoot(
doLS=self.do_newton,
maxIter=self.root_finder_max_iter,
tol=self.root_finder_tol,
Solver=self.Solver
)
return self._root_finder
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 = 25.
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 = Mesh.TensorMesh([hx, hy, hz],x0="CCC")
blkind0 = Utils.ModelBuilder.getIndicesSphere(np.r_[-100., -100., -200.], 75., mesh.gridCC)
blkind1 = Utils.ModelBuilder.getIndicesSphere(np.r_[100., 100., -200.], 75., mesh.gridCC)
sigma = np.ones(mesh.nC)*1e-2
airind = mesh.gridCC[:,2]>0.
sigma[airind] = 1e-8
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.01
actmapeta = Maps.InjectActiveCells(mesh, ~airind, 0.)
actmaptau = Maps.InjectActiveCells(mesh, ~airind, 1.)
x = mesh.vectorCCx[(mesh.vectorCCx>-155.)&(mesh.vectorCCx<155.)]
y = mesh.vectorCCx[(mesh.vectorCCy>-155.)&(mesh.vectorCCy<155.)]
Aloc = np.r_[-200., 0., 0.]
Bloc = np.r_[200., 0., 0.]
M = Utils.ndgrid(x-25.,y, np.r_[0.])
N = Utils.ndgrid(x+25.,y, 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])
colemap = [("eta", Maps.IdentityMap(mesh)*actmapeta), ("taui", Maps.IdentityMap(mesh)*actmaptau)]
problem = SIP.Problem3D_N(mesh, sigma=sigma, mapping=colemap)
problem.Solver = Solver
problem.pair(survey)
mSynth = np.r_[eta[~airind], 1./tau[~airind]]
survey.makeSyntheticData(mSynth)
# Now set up the problem to do some minimization
dmis = DataMisfit.l2_DataMisfit(survey)
regmap = Maps.IdentityMap(nP=int(mSynth[~airind].size*2))
reg = SIP.MultiRegularization(mesh, mapping=regmap, nModels=2, indActive=~airind)
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):
mesh = Mesh.TensorMesh([20, 20, 20], "CCN")
sigma = np.ones(mesh.nC) * 1. / 100.
actind = mesh.gridCC[:, 2] < -0.2
# actMap = Maps.InjectActiveCells(mesh, actind, 0.)
xyzM = Utils.ndgrid(
np.ones_like(mesh.vectorCCx[:-1]) * -0.4,
np.ones_like(mesh.vectorCCy) * -0.4, np.r_[-0.3])
xyzN = Utils.ndgrid(mesh.vectorCCx[1:], mesh.vectorCCy, np.r_[-0.3])
problem = SP.Problem_CC(mesh,
sigma=sigma,
qMap=Maps.IdentityMap(mesh),
Solver=PardisoSolver)
rx = SP.Rx.Dipole(xyzN, xyzM)
src = SP.Src.StreamingCurrents([rx],
L=np.ones(mesh.nC),
mesh=mesh,
modelType="CurrentSource")
survey = SP.Survey([src])
survey.pair(problem)
q = np.zeros(mesh.nC)
inda = Utils.closestPoints(mesh, np.r_[-0.5, 0., -0.8])
indb = Utils.closestPoints(mesh, np.r_[0.5, 0., -0.8])
q[inda] = 1.
q[indb] = -1.
mSynth = q.copy()
survey.makeSyntheticData(mSynth)
# Now set up the problem to do some minimization
dmis = DataMisfit.l2_DataMisfit(survey)
reg = Regularization.Simple(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=1e-2)
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(-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 solve(self):
# Tikhonov Inversion
####################
# Initial model values
m0 = np.median(self.ln_sigback) * np.ones(self.mapping.nP)
m0 += np.random.randn(m0.size)
# Misfit functional
dmis = DataMisfit.l2_DataMisfit(self.survey.simpeg_survey)
# Regularization functional
regT = Regularization.Simple(self.mesh,
alpha_s=10.0,
alpha_x=10.0,
alpha_y=10.0,
alpha_z=10.0,
indActive=self.actind)
# Personal preference for this solver with a Jacobi preconditioner
opt = Optimization.ProjectedGNCG(maxIter=8, tolX=1, maxIterCG=30)
#opt = Optimization.ProjectedGradient(maxIter=100, tolX=1e-2,
# maxIterLS=20, maxIterCG=30, tolCG=1e-4)
opt.printers.append(Optimization.IterationPrinters.iterationLS)
#print(opt.printersLS)
# Optimization class keeps value of 'xc'. Seems to be solution for the model parameters
opt.remember('xc')
invProb = InvProblem.BaseInvProblem(dmis, regT, opt)
# Options for the inversion algorithm in particular selection of Beta weight for regularization.
# How to choose initial estimate for beta
beta = Directives.BetaEstimate_ByEig(beta0_ratio=1.)
Target = Directives.TargetMisfit()
# Beta changing algorithm.
betaSched = Directives.BetaSchedule(coolingFactor=5., coolingRate=2)
# Change model weights, seems sensitivity of conductivity ?? Not sure.
updateSensW = Directives.UpdateSensitivityWeights(threshold=1e-3)
# Use Jacobi preconditioner ( the only available).
update_Jacobi = Directives.UpdatePreconditioner()
inv = Inversion.BaseInversion(invProb,
directiveList=[
beta, Target, betaSched, updateSensW,
update_Jacobi
])
self.minv = inv.run(m0)
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):
mesh = Mesh.TensorMesh([4, 4, 4])
# Magnetic inducing field parameter (A,I,D)
B = [50000, 90, 0]
# Create a MAGsurvey
rx = PF.BaseMag.RxObs(
np.vstack([[0.25, 0.25, 0.25], [-0.25, -0.25, 0.25]]))
srcField = PF.BaseMag.SrcField([rx], param=(B[0], B[1], B[2]))
survey = PF.BaseMag.LinearSurvey(srcField)
# Create the forward model operator
prob = PF.Magnetics.MagneticIntegral(mesh,
chiMap=Maps.IdentityMap(mesh))
# Pair the survey and problem
survey.pair(prob)
# Compute forward model some data
m = np.random.rand(mesh.nC)
survey.makeSyntheticData(m)
reg = Regularization.Sparse(mesh)
reg.mref = np.zeros(mesh.nC)
wr = np.sum(prob.G**2., axis=0)**0.5
reg.cell_weights = wr
reg.norms = [0, 1, 1, 1]
reg.eps_p, reg.eps_q = 1e-3, 1e-3
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey)
dmis.W = 1. / survey.std
# Add directives to the inversion
opt = Optimization.ProjectedGNCG(maxIter=2,
lower=-10.,
upper=10.,
maxIterCG=2)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
self.mesh = mesh
self.invProb = invProb
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 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
def solve(self):
# initial values/model
m0 = numpy.median(-4) * numpy.ones(self.mapping.nP)
# Data Misfit
dataMisfit = DataMisfit.l2_DataMisfit(self.survey)
# Regularization
regT = Regularization.Simple(self.mesh, indActive=self.activeCellIndices, alpha_s=1e-6, alpha_x=1., alpha_y=1., alpha_z=1.)
# Optimization Scheme
opt = Optimization.InexactGaussNewton(maxIter=10)
# Form the problem
opt.remember('xc')
invProb = InvProblem.BaseInvProblem(dataMisfit, regT, opt)
# Directives for Inversions
beta = Directives.BetaEstimate_ByEig(beta0_ratio=0.5e+1)
Target = Directives.TargetMisfit()
betaSched = Directives.BetaSchedule(coolingFactor=5., coolingRate=2)
inversion = Inversion.BaseInversion(invProb, directiveList=[beta, Target, betaSched])
# Run Inversion
self.invModelOnActiveCells = inversion.run(m0)
self.invModelOnAllCells = self.givenModelCond * numpy.ones_like(self.givenModelCond)
self.invModelOnAllCells[self.activeCellIndices] = self.invModelOnActiveCells
self.invModelOnCoreCells = self.invModelOnAllCells[self.coreMeshCellIndices]
pass
def setUp(self):
time = np.logspace(-3, 0, 21)
n_loc = 5
wires = Maps.Wires(('eta', n_loc), ('tau', n_loc), ('c', n_loc))
taumap = Maps.ExpMap(nP=n_loc) * wires.tau
etamap = Maps.ExpMap(nP=n_loc) * wires.eta
cmap = Maps.ExpMap(nP=n_loc) * wires.c
survey = SEMultiSurvey(time=time, locs=np.zeros((n_loc, 3)), n_pulse=0)
mesh = Mesh.TensorMesh([np.ones(int(n_loc * 3))])
prob = SEMultiInvProblem(mesh, etaMap=etamap, tauMap=taumap, cMap=cmap)
prob.pair(survey)
eta0, tau0, c0 = 0.1, 10., 0.5
m0 = np.log(np.r_[eta0 * np.ones(n_loc), tau0 * np.ones(n_loc),
c0 * np.ones(n_loc)])
survey.makeSyntheticData(m0)
# 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 = prob
self.survey = survey
self.m0 = m0
self.dmis = dmis
self.mesh = mesh
def resolve_1Dinversions(mesh,
dobs,
src_height,
freqs,
m0,
mref,
mapping,
std=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.array dobs: observed data
:param float src_height: height of the source above the ground
:param numpy.array freqs: frequencies
:param numpy.array m0: starting model
:param numpy.array mref: reference model
:param Maps.IdentityMap mapping: mapping that maps the model to electrical conductivity
:param float std: 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 = EM.FDEM.Rx.Point_bSecondary(np.array([[rxOffset, 0., src_height]]),
orientation='z',
component='real')
bzi = EM.FDEM.Rx.Point_b(np.array([[rxOffset, 0., src_height]]),
orientation='z',
component='imag')
# source location
srcLoc = np.array([0., 0., src_height])
srcList = [
EM.FDEM.Src.MagDipole([bzr, bzi], freq, srcLoc, orientation='Z')
for freq in freqs
]
# construct a forward simulation
survey = EM.FDEM.Survey(srcList)
prb = EM.FDEM.Problem3D_b(mesh, sigmaMap=mapping, Solver=PardisoSolver)
prb.pair(survey)
# ------------------- Inversion ------------------- #
# data misfit term
survey.dobs = dobs
dmisfit = DataMisfit.l2_DataMisfit(survey)
uncert = abs(dobs) * std + floor
dmisfit.W = 1. / uncert
# regularization
regMesh = Mesh.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 = InvProblem.BaseInvProblem(dmisfit, reg, opt)
# Inversion directives and parameters
target = Directives.TargetMisfit()
inv = Inversion.BaseInversion(invProb, directiveList=[target])
invProb.beta = 2. # Fix beta in the nonlinear iterations
reg.alpha_s = 1e-3
reg.alpha_x = 1.
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
reg_t = Regularization.Sparse(mesh, indActive=actv, mapping=wires.t)
reg_t.mref = np.zeros(3 * nC)
reg_t.cell_weights = (wires.t * wr)
reg = reg_p + reg_s + reg_t
reg.mref = np.zeros(3 * nC)
# Data misfit function
dmis = DataMisfit.l2_DataMisfit(survey)
dmis.W = 1. / survey.std
# Add directives to the inversion
opt = Optimization.ProjectedGNCG(maxIter=30,
lower=-10,
upper=10.,
maxIterLS=20,
maxIterCG=20,
tolCG=1e-4)
invProb = InvProblem.BaseInvProblem(dmis, reg, opt)
# A list of directive to control the inverson
betaest = Directives.BetaEstimate_ByEig()
# Here is where the norms are applied
# Use pick a treshold parameter empirically based on the distribution of
# model parameters
IRLS = Directives.Update_IRLS(f_min_change=1e-3, maxIRLSiter=0, beta_tol=5e-1)
# Pre-conditioner
update_Jacobi = Directives.UpdatePreconditioner()
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
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,
mtest = np.load('../Update_W_each_3it_5s_rademacher/finalresult.npy')
print "check misfit with W: ", dmis.eval(mtest) / survey.nD