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 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_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 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)