def test_regularization(self):
for R in dir(Regularization):
r = getattr(Regularization, R)
if not inspect.isclass(r): continue
if not issubclass(r, Regularization.BaseRegularization):
continue
for i, mesh in enumerate(self.meshlist):
print 'Testing {0:d}D'.format(mesh.dim)
mapping = r.mapPair(mesh)
reg = r(mesh, mapping=mapping)
m = np.random.rand(mapping.nP)
reg.mref = np.ones_like(m) * np.mean(m)
print 'Check: phi_m (mref) = {0:f}'.format(
reg.eval(reg.mref))
passed = reg.eval(reg.mref) < TOL
self.assertTrue(passed)
print 'Check:', R
passed = Tests.checkDerivative(
lambda m: [reg.eval(m), reg.evalDeriv(m)],
m,
plotIt=False)
self.assertTrue(passed)
print 'Check 2 Deriv:', R
passed = Tests.checkDerivative(
lambda m: [reg.evalDeriv(m),
reg.eval2Deriv(m)],
m,
plotIt=False)
self.assertTrue(passed)
def test_regularization_ActiveCells(self):
for R in dir(Regularization):
r = getattr(Regularization, R)
if not inspect.isclass(r):
continue
if not issubclass(r, Regularization.BaseRegularization):
continue
for i, mesh in enumerate(self.meshlist):
print('Testing Active Cells {0:d}D'.format((mesh.dim)))
if mesh.dim == 1:
indActive = Utils.mkvc(mesh.gridCC <= 0.8)
elif mesh.dim == 2:
indActive = Utils.mkvc(mesh.gridCC[:,-1] <= 2*np.sin(2*np.pi*mesh.gridCC[:,0])+0.5)
elif mesh.dim == 3:
indActive = Utils.mkvc(mesh.gridCC[:,-1] <= 2*np.sin(2*np.pi*mesh.gridCC[:,0])+0.5 * 2*np.sin(2*np.pi*mesh.gridCC[:,1])+0.5)
for indAct in [indActive, indActive.nonzero()[0]]: # test both bool and integers
reg = r(mesh, indActive=indAct)
m = np.random.rand(mesh.nC)[indAct]
reg.mref = np.ones_like(m)*np.mean(m)
print('Check: phi_m (mref) = {0:f}'.format(reg.eval(reg.mref)))
passed = reg.eval(reg.mref) < TOL
self.assertTrue(passed)
print('Check:', R)
passed = Tests.checkDerivative(lambda m : [reg.eval(m), reg.evalDeriv(m)], m, plotIt=False)
self.assertTrue(passed)
print('Check 2 Deriv:', R)
passed = Tests.checkDerivative(lambda m : [reg.evalDeriv(m), reg.eval2Deriv(m)], m, plotIt=False)
self.assertTrue(passed)
def test_regularization(self):
for R in dir(Regularization):
r = getattr(Regularization, R)
if not inspect.isclass(r):
continue
if not issubclass(r, Regularization.BaseRegularization):
continue
for i, mesh in enumerate(self.meshlist):
print('Testing {0:d}D'.format(mesh.dim))
mapping = r.mapPair(mesh)
reg = r(mesh, mapping=mapping)
m = np.random.rand(mapping.nP)
reg.mref = np.ones_like(m)*np.mean(m)
print('Check: phi_m (mref) = {0:f}'.format(reg.eval(reg.mref)))
passed = reg.eval(reg.mref) < TOL
self.assertTrue(passed)
print('Check: {}'.format(R))
passed = Tests.checkDerivative(lambda m: [reg.eval(m),
reg.evalDeriv(m)], m,
plotIt=False)
self.assertTrue(passed)
print('Check 2 Deriv: {}'.format(R))
passed = Tests.checkDerivative(lambda m: [reg.evalDeriv(m),
reg.eval2Deriv(m)], m,
plotIt=False)
self.assertTrue(passed)
def test_regularization_ActiveCells(self):
for R in dir(Regularization):
r = getattr(Regularization, R)
if not inspect.isclass(r):
continue
if not issubclass(r, Regularization.BaseRegularization):
continue
for i, mesh in enumerate(self.meshlist):
print('Testing Active Cells {0:d}D'.format((mesh.dim)))
if mesh.dim == 1:
indActive = Utils.mkvc(mesh.gridCC <= 0.8)
elif mesh.dim == 2:
indActive = Utils.mkvc(mesh.gridCC[:,-1] <= 2*np.sin(2*np.pi*mesh.gridCC[:,0])+0.5)
elif mesh.dim == 3:
indActive = Utils.mkvc(mesh.gridCC[:,-1] <= 2*np.sin(2*np.pi*mesh.gridCC[:,0])+0.5 * 2*np.sin(2*np.pi*mesh.gridCC[:,1])+0.5)
for indAct in [indActive, indActive.nonzero()[0]]: # test both bool and integers
reg = r(mesh, indActive=indAct)
m = np.random.rand(mesh.nC)[indAct]
reg.mref = np.ones_like(m)*np.mean(m)
print('Check: phi_m (mref) = {0:f}'.format(reg.eval(reg.mref)))
passed = reg.eval(reg.mref) < TOL
self.assertTrue(passed)
print('Check:', R)
passed = Tests.checkDerivative(lambda m : [reg.eval(m), reg.evalDeriv(m)], m, plotIt=False)
self.assertTrue(passed)
print('Check 2 Deriv:', R)
passed = Tests.checkDerivative(lambda m : [reg.evalDeriv(m), reg.eval2Deriv(m)], m, plotIt=False)
self.assertTrue(passed)
def JvecTest(self, prbtype, rxcomp):
prb, m, mesh = setUp_TDEM(prbtype, rxcomp)
def derChk(m):
return [prb.survey.dpred(m), lambda mx: prb.Jvec(m, mx)]
print("\ntest_Jvec_{}_{}".format(prbtype, rxcomp))
Tests.checkDerivative(derChk, m, plotIt=False, num=2, dx=m * 2, eps=1e-20)
def JvecTest(self, prbtype, rxcomp):
prb, m, mesh = setUp_TDEM(prbtype, rxcomp)
def derChk(m):
return [prb.survey.dpred(m), lambda mx: prb.Jvec(m, mx)]
print('\ntest_Jvec_{}_{}'.format(prbtype, rxcomp))
Tests.checkDerivative(derChk, m, plotIt=False, num=2, dx=m*2,
eps=1e-20)
def Deriv_J(self, rxcomp='bz'):
mesh, prb, m0 = setUp_TDEM(rxcomp)
prb.timeSteps = [(1e-05, 10), (0.0001, 10), (0.001, 10)]
def derChk(m):
return [prb.survey.dpred(m), lambda mx: prb.Jvec(m0, mx)]
print('test_Deriv_J {}'.format(rxcomp))
Tests.checkDerivative(derChk, m0, plotIt=False, num=3, eps=1e-20)
def JvecTest(self, rxcomp):
self.set_rxList(rxcomp)
def derChk(m):
return [
self.probfwd.survey.dpred(m),
lambda mx: self.prob.Jvec(self.m, mx, f=self.fields)
]
print('test_Jvec_{prbtype}_{rxcomp}'.format(prbtype=self.formulation,
rxcomp=rxcomp))
Tests.checkDerivative(derChk, self.m, plotIt=False, num=2, eps=1e-20)
def JvecTest(self, rxcomp):
self.set_rxList(rxcomp)
def derChk(m):
return [
self.probfwd.survey.dpred(m),
lambda mx: self.prob.Jvec(self.m, mx, f=self.fields)
]
print('test_Jvec_{prbtype}_{rxcomp}'.format(
prbtype=self.formulation, rxcomp=rxcomp)
)
Tests.checkDerivative(derChk, self.m, plotIt=False, num=2, eps=1e-20)
def test_linked_derivs_rho(self):
mesh = Mesh.TensorMesh([4, 5], x0='CC')
mapping = Maps.ExpMap(mesh)
propmap = MyReciprocalPropMap([('sigma', mapping)])
x0 = np.random.rand(mesh.nC)
m = propmap(x0)
# test Sigma
testme = lambda v: [1. / (m.sigmaMap * v), m.rhoDeriv]
print 'Testing Rho from Sigma'
Tests.checkDerivative(testme, x0, dx=0.01 * x0, num=5, plotIt=False)
def test_linked_derivs_rho(self):
mesh = Mesh.TensorMesh([4,5], x0='CC')
mapping = Maps.ExpMap(mesh)
propmap = MyReciprocalPropMap([('sigma', mapping)])
x0 = np.random.rand(mesh.nC)
m = propmap(x0)
# test Sigma
testme = lambda v: [1./(m.sigmaMap*v), m.rhoDeriv]
print('Testing Rho from Sigma')
Tests.checkDerivative(testme, x0, dx=0.01*x0, num=5, plotIt=False)
def test_EM1DTDJtvec_Layers(self):
sig_blk = 0.1
sig = np.ones(self.prob.survey.n_layer) * self.sig_half
sig[3] = sig_blk
m_true = np.log(sig)
dobs = self.prob.survey.dpred(m_true)
m_ini = np.log(np.ones(self.prob.survey.n_layer) * self.sig_half)
resp_ini = self.prob.survey.dpred(m_ini)
dr = resp_ini - dobs
def misfit(m, dobs):
dpred = self.survey.dpred(m)
misfit = 0.5 * np.linalg.norm(dpred - dobs)**2
dmisfit = self.prob.Jtvec(m, dr)
return misfit, dmisfit
derChk = lambda m: misfit(m, dobs)
passed = Tests.checkDerivative(derChk,
m_ini,
num=4,
plotIt=False,
eps=1e-26)
self.assertTrue(passed)
if passed:
print("EM1DTD-layers Jtvec works")
def test_dataObj(self):
passed = Tests.checkDerivative(
lambda m: [self.dmis.eval(m), self.dmis.evalDeriv(m)],
self.m0,
plotIt=False
)
self.assertTrue(passed)
def test_EM1DTDJtvec_Layers(self):
sig_blk = 0.1
sig = np.ones(self.prob.survey.n_layer)*self.sig_half
sig[3] = sig_blk
m_true = np.log(sig)
dobs = self.prob.survey.dpred(m_true)
m_ini = np.log(np.ones(self.prob.survey.n_layer)*self.sig_half)
resp_ini = self.prob.survey.dpred(m_ini)
dr = resp_ini-dobs
def misfit(m, dobs):
dpred = self.survey.dpred(m)
misfit = 0.5*np.linalg.norm(dpred-dobs)**2
dmisfit = self.prob.Jtvec(m, dr)
return misfit, dmisfit
derChk = lambda m: misfit(m, dobs)
passed = Tests.checkDerivative(
derChk, m_ini, num=4, plotIt=False, eps=1e-26
)
self.assertTrue(passed)
if passed:
print ("EM1DTD-layers Jtvec works")
def test_misfit(self):
passed = Tests.checkDerivative(
lambda m:
[self.survey.dpred(m), lambda mx: self.p.Jvec(self.m0, mx)],
self.m0,
plotIt=False)
self.assertTrue(passed)
def test_deriv(self):
s = Utils.mkvc(Utils.ModelBuilder.randomModel(self.M.vnC)) + 1.
def fun(x):
return self.survey.dpred(x), lambda x: self.problem.Jvec(s, x)
return Tests.checkDerivative(fun, s, num=4, plotIt=False, eps=FLR)
def test_e_deriv(self):
x0 = -1 + 1e-1 * np.random.rand(self.sigma_map.nP)
def fun(x):
return self.survey.dpred(x), lambda x: self.prob.Jvec(x0, x)
return Tests.checkDerivative(fun, x0, num=3, plotIt=False)
def test_dataObj(self):
passed = Tests.checkDerivative(lambda m:
(self.dmis(m), self.dmis.deriv(m)),
self.m0,
plotIt=False,
num=3)
self.assertTrue(passed)
def test_dataObj(self):
passed = Tests.checkDerivative(
lambda m: [self.dmis(m), self.dmis.deriv(m)],
self.m0,
plotIt=False,
num=3
)
self.assertTrue(passed)
def test_FaceInnerProductIsotropicDeriv(self):
def fun(x):
MfSig = self.mesh.getFaceInnerProduct(x)
MfSigDeriv = self.mesh.getFaceInnerProductDeriv(self.x0)
return MfSig*self.face_vec, MfSigDeriv(self.face_vec)
print('Testing FaceInnerProduct Isotropic')
return self.assertTrue(Tests.checkDerivative(fun, self.x0, num=7,
tolerance=TOLD, plotIt=False))
def test_misfit(self):
passed = Tests.checkDerivative(
lambda m: [
self.survey.dpred(m), lambda mx: self.p.Jvec(self.m0, mx)
],
self.m0,
plotIt=False,
num=3
)
self.assertTrue(passed)
def test_derivs(self):
Tests.checkDerivative(CasingMagDipoleDeriv_r,
np.ones(n) * 10 + np.random.randn(n),
plotIt=False)
Tests.checkDerivative(CasingMagDipoleDeriv_z,
np.random.randn(n),
plotIt=False)
Tests.checkDerivative(CasingMagDipole2Deriv_z_r,
np.ones(n) * 10 + np.random.randn(n),
plotIt=False)
Tests.checkDerivative(CasingMagDipole2Deriv_z_z,
np.random.randn(n),
plotIt=False)
def JvecTest(self, prbtype='e', sigmaInInversion=False, invertMui=False):
self.setUpProb(prbtype, sigmaInInversion, invertMui)
print('Testing Jvec {}'.format(prbtype))
def fun(x):
return (
self.prob.survey.dpred(x), lambda x: self.prob.Jvec(self.m0, x)
)
return Tests.checkDerivative(
fun, self.m0, num=2, plotIt=False, eps=EPS
)
def JvecTest(self):
print('\nTesting Jvec')
x0 = model
def fun(x):
return [
self.secondarySurvey.dpred(x), lambda x: self.secondaryProblem.
Jvec(x0, x, f=self.fields_primsec)
]
return Tests.checkDerivative(fun, x0, num=2, plotIt=False)
def dotestJvec(prb, mesh, sigma):
prb.timeSteps = [(1e-05, 10), (0.0001, 10), (0.001, 10)]
# d_sig = 0.8*sigma #np.random.rand(mesh.nCz)
d_sig = 10 * np.random.rand(prb.mapping.nP)
derChk = lambda m: [prb.survey.dpred(m), lambda mx: prb.Jvec(sigma, mx)]
return Tests.checkDerivative(derChk,
sigma,
plotIt=False,
dx=d_sig,
num=2,
eps=1e-20)
def test_Deriv_J(self):
prb = self.prb
prb.timeSteps = [(1e-05, 10), (0.0001, 10), (0.001, 10)]
mesh = self.mesh
sigma = self.sigma
# d_sig = 0.8*sigma #np.random.rand(mesh.nCz)
d_sig = 10 * np.random.rand(prb.mapping.nP)
derChk = lambda m: [
prb.survey.dpred(m), lambda mx: prb.Jvec(sigma, mx)
]
print '\n'
print 'test_Deriv_J'
Tests.checkDerivative(derChk,
sigma,
plotIt=False,
dx=d_sig,
num=4,
eps=1e-20)
def JvecTest(self):
print('\nTesting Jvec')
x0 = model
def fun(x):
return [
self.secondarySurvey.dpred(x),
lambda x: self.secondaryProblem.Jvec(
x0, x, f=self.fields_primsec
)
]
return Tests.checkDerivative(fun, x0, num=2, plotIt=False)
def test_EdgeInnerProductIsotropicDerivInvMat(self):
def fun(x):
MeSig = self.mesh.getEdgeInnerProduct(x, invMat=True)
MeSigDeriv = self.mesh.getEdgeInnerProductDeriv(self.x0,
invMat=True)
return MeSig*self.edge_vec, MeSigDeriv(self.edge_vec)
print('Testing EdgeInnerProduct Isotropic InvMat')
return self.assertTrue(Tests.checkDerivative(fun, self.x0, num=7,
tolerance=TOLD,
plotIt=False))
def test_Deriv_dUdM(self):
prb = self.prb
prb.timeSteps = [(1e-05, 10), (0.0001, 10), (0.001, 10)]
mesh = self.mesh
sigma = self.sigma
dm = 10 * np.random.rand(prb.mapping.nP)
f = prb.fields(sigma)
derChk = lambda m: [
self.prb.fields(m).tovec(), lambda mx: -prb.solveAh(
sigma, prb.Gvec(sigma, mx, u=f)).tovec()
]
print '\n'
print 'test_Deriv_dUdM'
Tests.checkDerivative(derChk,
sigma,
plotIt=False,
dx=dm,
num=4,
eps=1e-20)
def test_EdgeInnerProductIsotropicDeriv(self):
def fun(x):
MeSig = self.mesh.getEdgeInnerProduct(x)
MeSigDeriv = self.mesh.getEdgeInnerProductDeriv(self.x0)
return MeSig * self.edge_vec, MeSigDeriv(self.edge_vec)
print('Testing EdgeInnerProduct Isotropic')
return self.assertTrue(
Tests.checkDerivative(fun,
self.x0,
num=7,
tolerance=TOLD,
plotIt=False))
def AderivTest(self, prbtype):
prb, m0, mesh = setUp_TDEM(prbtype)
tInd = 2
if prbtype == 'b':
nu = mesh.nF
elif prbtype == 'e':
nu = mesh.nE
v = np.random.rand(nu)
def AderivFun(m):
prb.curModel = m
A = prb.getAdiag(tInd)
Av = A * v
prb.curModel = m0
def ADeriv_dm(dm):
return prb.getAdiagDeriv(tInd, v, dm)
return Av, ADeriv_dm
print('\n Testing ADeriv {}'.format(prbtype))
Tests.checkDerivative(AderivFun, m0, plotIt=False, num=3, eps=1e-20)
def AderivTest(self, prbtype):
prb, m0, mesh = setUp_TDEM(prbtype)
tInd = 2
if prbtype == "b":
nu = mesh.nF
elif prbtype == "e":
nu = mesh.nE
v = np.random.rand(nu)
def AderivFun(m):
prb.curModel = m
A = prb.getAdiag(tInd)
Av = A * v
prb.curModel = m0
def ADeriv_dm(dm):
return prb.getAdiagDeriv(tInd, v, dm)
return Av, ADeriv_dm
print("\n Testing ADeriv {}".format(prbtype))
Tests.checkDerivative(AderivFun, m0, plotIt=False, num=4, eps=1e-20)
def test_FaceInnerProductIsotropicDerivInvMat(self):
def fun(x):
MfSig = self.mesh.getFaceInnerProduct(x, invMat=True)
MfSigDeriv = self.mesh.getFaceInnerProductDeriv(self.x0,
invMat=True)
return MfSig * self.face_vec, MfSigDeriv(self.face_vec)
print('Testing FaceInnerProduct Isotropic InvMat')
return self.assertTrue(
Tests.checkDerivative(fun,
self.x0,
num=7,
tolerance=TOLD,
plotIt=False))
def test_DerivG(self):
"""
Test the derivative of c with respect to sigma
"""
# Random model and perturbation
sigma = np.random.rand(self.prb.mapping.nP)
f = self.prb.fields(sigma)
dm = 1000 * np.random.rand(self.prb.mapping.nP)
h = 0.01
derChk = lambda m: [
self.prb._AhVec(m, f).tovec(), lambda mx: self.prb.Gvec(
sigma, mx, u=f).tovec()
]
print '\ntest_DerivG'
Tests.checkDerivative(derChk,
sigma,
plotIt=False,
dx=dm,
num=4,
eps=1e-20)
def derivTest(fdemType, comp):
prb = getFDEMProblem(fdemType, comp, SrcType, freq)
print '{0!s} formulation - {1!s}'.format(fdemType, comp)
x0 = np.log(np.ones(prb.mapping.nP) * CONDUCTIVITY)
mu = np.log(np.ones(prb.mesh.nC) * MU)
if addrandoms is True:
x0 = x0 + np.random.randn(prb.mapping.nP) * np.log(CONDUCTIVITY) * 1e-1
mu = mu + np.random.randn(prb.mapping.nP) * MU * 1e-1
survey = prb.survey
def fun(x):
return survey.dpred(x), lambda x: prb.Jvec(x0, x)
return Tests.checkDerivative(fun, x0, num=2, plotIt=False, eps=FLR)
def doTestFace(self, h, rep, fast, meshType, invProp=False, invMat=False):
if meshType == 'Curv':
hRect = Utils.exampleLrmGrid(h,'rotate')
mesh = Mesh.CurvilinearMesh(hRect)
elif meshType == 'Tree':
mesh = Mesh.TreeMesh(h, levels=3)
mesh.refine(lambda xc: 3)
mesh.number(balance=False)
elif meshType == 'Tensor':
mesh = Mesh.TensorMesh(h)
v = np.random.rand(mesh.nF)
sig = np.random.rand(1) if rep is 0 else np.random.rand(mesh.nC*rep)
def fun(sig):
M = mesh.getFaceInnerProduct(sig, invProp=invProp, invMat=invMat)
Md = mesh.getFaceInnerProductDeriv(sig, invProp=invProp, invMat=invMat, doFast=fast)
return M*v, Md(v)
print(meshType, 'Face', h, rep, fast, ('harmonic' if invProp and invMat else 'standard'))
return Tests.checkDerivative(fun, sig, num=5, plotIt=False)
def doTestFace(self, h, rep, fast, meshType, invProp=False, invMat=False):
if meshType == 'Curv':
hRect = Utils.exampleLrmGrid(h,'rotate')
mesh = Mesh.CurvilinearMesh(hRect)
elif meshType == 'Tree':
mesh = Mesh.TreeMesh(h, levels=3)
mesh.refine(lambda xc: 3)
mesh.number(balance=False)
elif meshType == 'Tensor':
mesh = Mesh.TensorMesh(h)
v = np.random.rand(mesh.nF)
sig = np.random.rand(1) if rep is 0 else np.random.rand(mesh.nC*rep)
def fun(sig):
M = mesh.getFaceInnerProduct(sig, invProp=invProp, invMat=invMat)
Md = mesh.getFaceInnerProductDeriv(sig, invProp=invProp, invMat=invMat, doFast=fast)
return M*v, Md(v)
print meshType, 'Face', h, rep, fast, ('harmonic' if invProp and invMat else 'standard')
return Tests.checkDerivative(fun, sig, num=5, plotIt=False)
def derivTest(fdemType, comp):
prb = getFDEMProblem(fdemType, comp, SrcType, freq)
# prb.solverOpts = dict(check_accuracy=True)
print('{0!s} formulation - {1!s}'.format(fdemType, comp))
x0 = np.log(np.ones(prb.mapping.nP)*CONDUCTIVITY)
mu = np.log(np.ones(prb.mesh.nC)*MU)
if addrandoms is True:
x0 = x0 + np.random.randn(prb.mapping.nP)*np.log(CONDUCTIVITY)*1e-1
mu = mu + np.random.randn(prb.mapping.nP)*MU*1e-1
survey = prb.survey
def fun(x):
return survey.dpred(x), lambda x: prb.Jvec(x0, x)
return Tests.checkDerivative(fun, x0, num=2, plotIt=False, eps=FLR)
def test_EdgeInnerProductAnisotropicDerivInvMat(self):
def fun(x):
x = np.repeat(np.atleast_2d(x), 3, axis=0).T
x0 = np.repeat(self.x0, 3, axis=0).T
Zero = sp.csr_matrix((self.mesh.nC, self.mesh.nC))
Eye = sp.eye(self.mesh.nC)
P = sp.vstack([sp.hstack([Zero, Eye, Zero])])
MeSig = self.mesh.getEdgeInnerProduct(x, invMat=True)
MeSigDeriv = self.mesh.getEdgeInnerProductDeriv(x0, invMat=True)
return MeSig*self.edge_vec, MeSigDeriv(self.edge_vec) * P.T
print('Testing EdgeInnerProduct Anisotropic InvMat')
return self.assertTrue(Tests.checkDerivative(fun, self.x0, num=7,
tolerance=TOLD,
plotIt=False))
def test_FaceInnerProductAnisotropicDeriv(self):
def fun(x):
# fake anisotropy (testing anistropic implementation with isotropic
# vector). First order behavior expected for fully anisotropic
x = np.repeat(np.atleast_2d(x), 3, axis=0).T
x0 = np.repeat(self.x0, 3, axis=0).T
Zero = sp.csr_matrix((self.mesh.nC, self.mesh.nC))
Eye = sp.eye(self.mesh.nC)
P = sp.vstack([sp.hstack([Eye, Zero, Eye])])
MfSig = self.mesh.getFaceInnerProduct(x)
MfSigDeriv = self.mesh.getFaceInnerProductDeriv(x0)
return MfSig*self.face_vec , MfSigDeriv(self.face_vec) * P.T
print('Testing FaceInnerProduct Anisotropic')
return self.assertTrue(Tests.checkDerivative(fun, self.x0, num=7,
tolerance=TOLD, plotIt=False))
def test_EdgeInnerProductAnisotropicDerivInvMat(self):
def fun(x):
x = np.repeat(np.atleast_2d(x), 3, axis=0).T
x0 = np.repeat(self.x0, 3, axis=0).T
Zero = sp.csr_matrix((self.mesh.nC, self.mesh.nC))
Eye = sp.eye(self.mesh.nC)
P = sp.vstack([sp.hstack([Zero, Eye, Zero])])
MeSig = self.mesh.getEdgeInnerProduct(x, invMat=True)
MeSigDeriv = self.mesh.getEdgeInnerProductDeriv(x0, invMat=True)
return MeSig * self.edge_vec, MeSigDeriv(self.edge_vec) * P.T
print('Testing EdgeInnerProduct Anisotropic InvMat')
return self.assertTrue(
Tests.checkDerivative(fun,
self.x0,
num=7,
tolerance=TOLD,
plotIt=False))
def test_EM1DTDJvec_Layers(self):
sig = np.ones(self.prob.survey.n_layer)*self.sig_half
m_1D = np.log(sig)
def fwdfun(m):
resp = self.prob.survey.dpred(m)
return resp
def jacfun(m, dm):
Jvec = self.prob.Jvec(m, dm)
return Jvec
dm = m_1D*0.5
derChk = lambda m: [fwdfun(m), lambda mx: jacfun(m, mx)]
passed = Tests.checkDerivative(
derChk, m_1D, num=4, dx=dm, plotIt=False, eps=1e-15
)
if passed:
print ("EM1DTD-layers Jvec works")
def test_FaceInnerProductAnisotropicDeriv(self):
def fun(x):
# fake anisotropy (testing anistropic implementation with isotropic
# vector). First order behavior expected for fully anisotropic
x = np.repeat(np.atleast_2d(x), 3, axis=0).T
x0 = np.repeat(self.x0, 3, axis=0).T
Zero = sp.csr_matrix((self.mesh.nC, self.mesh.nC))
Eye = sp.eye(self.mesh.nC)
P = sp.vstack([sp.hstack([Eye, Zero, Eye])])
MfSig = self.mesh.getFaceInnerProduct(x)
MfSigDeriv = self.mesh.getFaceInnerProductDeriv(x0)
return MfSig * self.face_vec, MfSigDeriv(self.face_vec) * P.T
print('Testing FaceInnerProduct Anisotropic')
return self.assertTrue(
Tests.checkDerivative(fun,
self.x0,
num=7,
tolerance=TOLD,
plotIt=False))
def test_EM1DTDJvec_Layers(self):
sig = np.ones(self.prob.survey.n_layer) * self.sig_half
m_1D = np.log(sig)
def fwdfun(m):
resp = self.prob.survey.dpred(m)
return resp
def jacfun(m, dm):
Jvec = self.prob.Jvec(m, dm)
return Jvec
dm = m_1D * 0.5
derChk = lambda m: [fwdfun(m), lambda mx: jacfun(m, mx)]
passed = Tests.checkDerivative(derChk,
m_1D,
num=4,
dx=dm,
plotIt=False,
eps=1e-15)
if passed:
print("EM1DTD-layers Jvec works")
def test_dataObj(self):
derChk = lambda m: [self.dmis.eval(m), self.dmis.evalDeriv(m)]
passed = Tests.checkDerivative(derChk, self.m0, plotIt=False, num=3)
self.assertTrue(passed)
def derivtest(self, deriv_fct):
m0 = np.log(self.sigma) + np.random.rand(self.mesh.nC)
self.prob.model = m0
return Tests.checkDerivative(deriv_fct, np.log(self.sigma), num=3, plotIt=False)
def test_dataObj(self):
derChk = lambda m: [self.dmis.eval(m), self.dmis.evalDeriv(m)]
passed = Tests.checkDerivative(derChk, self.m0, plotIt=False, num=3)
self.assertTrue(passed)
def test_misfit(self):
derChk = lambda m: [
self.survey.dpred(m), lambda mx: self.p.Jvec(self.m0, mx)
]
passed = Tests.checkDerivative(derChk, self.m0, plotIt=False, num=3)
self.assertTrue(passed)
def test_deriv(self):
s = Utils.mkvc(Utils.ModelBuilder.randomModel(self.M.vnC)) + 1.
def fun(x):
return self.survey.dpred(x), lambda x: self.problem.Jvec(s, x)
return Tests.checkDerivative(fun, s, num=4, plotIt=False, eps=FLR)
def run(
self, plotIt=False, runTests=False, verbose=True, saveFields=True,
saveFig=False
):
self.verbose = verbose
if plotIt is True: # Plot the Primary Model
# self.plotPrimaryMesh() # plot the mesh
self.plotPrimaryProperties() # plot mu, sigma
# Primary Simulation
self.primaryProblem.pair(self.primarySurvey)
primfields = self.solvePrimary(self.primaryProblem, m=self.mtrue)
if saveFields is True:
np.save('primaryfields_' + self.NAME, primfields[:, :])
print(' saved %s' % 'primaryfields_' + self.NAME)
mback = self.mtrue.copy()
mback[2] = np.log(self.sigmalayer)
# Secondary Problem and Survey
sec_problem = self.setupSecondaryProblem(mapping=self.mapping)
sec_survey = self.setupSecondarySurvey(
self.primaryProblem, self.primarySurvey, self.primaryMap2meshs
)
sec_problem.pair(sec_survey)
# layered earth only (background)
background_problem = self.setupSecondaryProblem(
mapping=self.primaryMap2meshs
)
background_survey = self.setupSecondarySurvey(
self.primaryProblem, self.primarySurvey, self.primaryMap2meshs
)
background_problem.pair(background_survey)
# -------------- Test the sensitivity ----------------------------- #
if runTests:
x0 = self.mtrue
# Test Block Model
def fun(x):
return [
sec_survey.dpred(x),
lambda x: sec_problem.Jvec(self.mtrue, x)
]
Tests.checkDerivative(fun, self.mtrue, num=2, plotIt=False)
# -------------- Calculate Fields --------------------------------- #
# Background
t0 = time.time()
print('solving background ... ')
fieldsback, dpredback = self.solveSecondary(
background_problem, background_survey, self.mtrue
)
t1 = time.time()
print('... done. dpred_back {}'.format(t1-t0))
if saveFields:
np.save('dpred_' + self.NAME + '_back', dpredback)
np.save('fields_' + self.NAME + '_back', fieldsback[:, :])
print(' saved {}'.format(self.NAME + '_back'))
# with Block
t0 = time.time()
print('solving with block ... ')
fields, dpred = self.solveSecondary(
sec_problem, sec_survey, self.mtrue
)
print('... done. dpred {}'.format(t1-t0))
if saveFields:
np.save('dpred_' + self.NAME, dpred)
np.save('fields_' + self.NAME, fields[:, :])
print(' saved {}'.format(self.NAME))
t1 = time.time()
# -------------- Calculate J --------------------------------- #
# Calculate J with block
print('starting J with block')
t0 = time.time()
J = []
for i in range(len(self.mtrue)):
ei = np.zeros_like(self.mtrue)
ei[i] = 1.
J.append(sec_problem.Jvec(self.mtrue, ei, f=fields))
J = np.vstack(J)
t1 = time.time()
print(' J {}'.format(t1-t0))
if saveFields is True:
np.save('J_' + self.NAME, J)
print(' saved {}'.format('J_' + self.NAME))
return {
'primfields': primfields, # primary fields
'fieldsback': fieldsback, # fields without block
'dpredback': dpredback, # predicted data without block
'fields': fields, # fields with block
'dpred': dpred, # predicted data with block
'J': J # sensitivity
}
def test_e_deriv(self):
x0 = -1 + 1e-1*np.random.rand(self.sigma_map.nP)
def fun(x):
return self.survey.dpred(x), lambda x: self.prob.Jvec(x0, x)
return Tests.checkDerivative(fun, x0, num=3, plotIt=False)
def test_derivs(self):
Tests.checkDerivative(CasingMagDipoleDeriv_r, np.ones(n)*10+np.random.randn(n), plotIt=False)
Tests.checkDerivative(CasingMagDipoleDeriv_z, np.random.randn(n), plotIt=False)
Tests.checkDerivative(CasingMagDipole2Deriv_z_r, np.ones(n)*10+np.random.randn(n), plotIt=False)
Tests.checkDerivative(CasingMagDipole2Deriv_z_z, np.random.randn(n), plotIt=False)
def test_misfit(self):
derChk = lambda m: [self.survey.dpred(m), lambda mx: self.p.Jvec(self.m0, mx)]
passed = Tests.checkDerivative(derChk, self.m0, plotIt=False)
self.assertTrue(passed)
