def getCoreModel(self, Type): if Type == 'Layer': active = self.mesh2D.vectorCCy < self.z0 ind1 = ((self.mesh2D.vectorCCy < self.z0) & (self.mesh2D.vectorCCy >= self.z1)) ind2 = ((self.mesh2D.vectorCCy < self.z1) & (self.mesh2D.vectorCCy >= self.z2)) mapping2D = ( Maps.SurjectVertical1D(self.mesh2D) * Maps.InjectActiveCells( self.mesh2D, active, self.sig0, nC=self.mesh2D.nCy)) model2D = np.ones(self.mesh2D.nCy) * self.sig3 model2D[ind1] = self.sig1 model2D[ind2] = self.sig2 model2D = model2D[active] elif Type == 'Sphere': active = self.mesh2D.gridCC[:, 1] < self.z0 ind1 = ((self.mesh2D.gridCC[:, 1] < self.z1) & (self.mesh2D.gridCC[:, 1] >= self.z1 - self.h)) ind2 = np.sqrt((self.mesh2D.gridCC[:, 0])**2 + (self.mesh2D.gridCC[:, 1] - self.z2)**2) <= self.R mapping2D = (Maps.InjectActiveCells(self.mesh2D, active, self.sig0, nC=self.mesh2D.nC)) model2D = np.ones(self.mesh2D.nC) * self.sigb model2D[ind1] = self.sig1 model2D[ind2] = self.sig2 model2D = model2D[active] return model2D, mapping2D
def spectral_ip_mappings(mesh, indActive=None, inactive_eta=1e-4, inactive_tau=1e-4, inactive_c=1e-4, is_log_eta=True, is_log_tau=True, is_log_c=True): """ Generates Mappings for Spectral Induced Polarization Problem. Three parameters are required to be input: Chargeability (eta), Time constant (tau), and Frequency dependency (c). If there is no topography (indActive is None), model (m) can be either set to m = np.r_[log(eta), log(tau), log(c)] or m = np.r_[eta, tau, c] When indActive is not None, m is m = np.r_[log(eta[indAcitve]), log(tau[indAcitve]), log(c[indAcitve])] or m = np.r_[eta[indAcitve], tau[indAcitve], c[indAcitve]] or TODO: Illustrate input and output variables """ if indActive is None: indActive = np.ones(mesh.nC, dtype=bool) actmap_eta = Maps.InjectActiveCells(mesh, indActive=indActive, valInactive=inactive_eta) actmap_tau = Maps.InjectActiveCells(mesh, indActive=indActive, valInactive=inactive_tau) actmap_c = Maps.InjectActiveCells(mesh, indActive=indActive, valInactive=inactive_c) wires = Maps.Wires(('eta', indActive.sum()), ('tau', indActive.sum()), ('c', indActive.sum())) if is_log_eta: eta_map = actmap_eta * Maps.ExpMap(nP=actmap_eta.nP) * wires.eta else: eta_map = actmap_eta * wires.eta if is_log_tau: tau_map = actmap_tau * Maps.ExpMap(nP=actmap_tau.nP) * wires.tau else: tau_map = actmap_tau * wires.tau if is_log_c: c_map = actmap_c * Maps.ExpMap(nP=actmap_c.nP) * wires.c else: c_map = actmap_c * wires.c return eta_map, tau_map, c_map, wires
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): cs = 5. ncx = 20 ncy = 6 npad = 20 hx = [(cs, ncx), (cs, npad, 1.3)] hy = [(cs, npad, -1.3), (cs, ncy), (cs, npad, 1.3)] mesh = Mesh.CylMesh([hx, 1, hy], '00C') active = mesh.vectorCCz < 0. activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap rxOffset = 40. rx = EM.TDEM.RxTDEM(np.array([[rxOffset, 0., 0.]]), np.logspace(-4, -3, 20), 'bz') src = EM.TDEM.SrcTDEM_VMD_MVP([rx], loc=np.array([0., 0., 0.])) survey = EM.TDEM.SurveyTDEM([src]) self.prb = EM.TDEM.ProblemTDEM_b(mesh, mapping=mapping) # self.prb.timeSteps = [1e-5] self.prb.timeSteps = [(1e-05, 10), (5e-05, 10), (2.5e-4, 10)] # self.prb.timeSteps = [(1e-05, 100)] try: from pymatsolver import MumpsSolver self.prb.Solver = MumpsSolver except ImportError, e: self.prb.Solver = SolverLU
def setUp(self): cs = 10 nc = 20 npad = 10 mesh = Mesh.CylMesh([[(cs, nc), (cs, npad, 1.3)], np.r_[2 * np.pi], [(cs, npad, -1.3), (cs, nc), (cs, npad, 1.3)]]) mesh.x0 = np.r_[0., 0., -mesh.hz[:npad + nc].sum()] # receivers rx_x = np.linspace(10, 200, 20) rx_z = np.r_[-5] rx_locs = Utils.ndgrid([rx_x, np.r_[0], rx_z]) rx_list = [DC.Rx.BaseRx(rx_locs, 'ex')] # sources src_a = np.r_[0., 0., -5.] src_b = np.r_[55., 0., -5.] src_list = [DC.Src.Dipole(rx_list, locA=src_a, locB=src_b)] self.mesh = mesh self.sigma_map = Maps.ExpMap(mesh) * Maps.InjectActiveCells( mesh, mesh.gridCC[:, 2] <= 0, np.log(1e-8)) self.prob = DC.Problem3D_CC(mesh, sigmaMap=self.sigma_map, Solver=Pardiso, bc_type="Dirichlet") self.survey = DC.Survey(src_list) self.prob.pair(self.survey)
def setThreeLayerParam(self, h1=12, h2=12, sig0=1e-8, sig1=1e-2, sig2=1e-2, sig3=1e-2, chi=0.): self.h1 = h1 # 1st layer thickness self.h2 = h2 # 2nd layer thickness self.z0 = 0. self.z1 = self.z0 - h1 self.z2 = self.z0 - h1 - h2 self.sig0 = sig0 # 0th layer \sigma (assumed to be air) self.sig1 = sig1 # 1st layer \sigma self.sig2 = sig2 # 2nd layer \sigma self.sig3 = sig3 # 3rd layer \sigma active = self.mesh.vectorCCz < self.z0 ind1 = ((self.mesh.vectorCCz < self.z0) & (self.mesh.vectorCCz >= self.z1)) ind2 = ((self.mesh.vectorCCz < self.z1) & (self.mesh.vectorCCz >= self.z2)) self.mapping = ( Maps.SurjectVertical1D(self.mesh) * Maps.InjectActiveCells(self.mesh, active, sig0, nC=self.mesh.nCz)) model = np.ones(self.mesh.nCz) * sig3 model[ind1] = sig1 model[ind2] = sig2 self.m = model[active] self.mu = np.ones(self.mesh.nC) * mu_0 self.mu[self.mesh.gridCC[:, 2] < 0.] = (1. + chi) * mu_0 return self.m
def muModel(self): # Mu Model # here, we want to consider variable magnetic permeability in the # simulation. The only permeable item in the domain is the casing. if getattr(self, '_muModel', None) is None: if getattr(self, '_paramMapPrimary', None) is None: self.primaryMapping muMap = (Maps.InjectActiveCells( self.meshp, self.indActivePrimary, mu_0) * self._paramMapPrimary) muModel = muMap * np.hstack( np.r_[ mu_0, # val Background mu_0, # val Layer mu_0*self.mucasing, # val Casing mu_0, # val inside Casing self.layer_z.mean(), # layer center self.layer_z[1] - self.layer_z[0], # layer thickness self.casing_r, # casing radius self.casing_t, # casing thickness self.casing_z[0], # casing bottom self.casing_z[1] # casing top ] ) self._muModel = muModel return self._muModel
def test_tripleMultiply(self): M = Mesh.TensorMesh([2, 4], '0C') expMap = Maps.ExpMap(M) vertMap = Maps.SurjectVertical1D(M) actMap = Maps.InjectActiveCells(M, M.vectorCCy <= 0, 10, nC=M.nCy) m = np.r_[1., 2.] t_true = np.exp(np.r_[1, 1, 2, 2, 10, 10, 10, 10.]) self.assertLess( np.linalg.norm((expMap * vertMap * actMap * m) - t_true, np.inf), TOL) self.assertLess( np.linalg.norm(((expMap * vertMap * actMap) * m) - t_true, np.inf), TOL) self.assertLess( np.linalg.norm((expMap * vertMap * (actMap * m)) - t_true, np.inf), TOL) self.assertLess( np.linalg.norm((expMap * (vertMap * actMap) * m) - t_true, np.inf), TOL) self.assertLess( np.linalg.norm(((expMap * vertMap) * actMap * m) - t_true, np.inf), TOL) self.assertRaises(ValueError, lambda: expMap * actMap * vertMap) self.assertRaises(ValueError, lambda: actMap * vertMap * expMap)
def setup(self): self.setup_geometry() self.setup_measurement() # Setup Problem with exponential mapping and Active cells only in the core mesh expmap = Maps.ExpMap(self.mesh) mapactive = Maps.InjectActiveCells(mesh=self.mesh, indActive=self.actind, valInactive=-5.) self.mapping = expmap * mapactive problem = DC.Problem3D_CC(self.mesh, sigmaMap=self.mapping) problem.pair(self.survey.simpeg_survey) problem.Solver = Solver # Compute prediction using the forward model and true conductivity data. # survey.dpred(mtrue[actind]) # Make synthetic data adding a noise to the prediction. # In fact prediction is computed again. self.set_syntetic_conductivity() #self.survey.simpeg_survey.makeSyntheticData(self.mtrue[self.actind], std=0.05, force=True) m = self.mtrue[self.actind] std = 0.05 dtrue = self.survey.simpeg_survey.dpred(m, f=None) noise = std*abs(dtrue)*np.random.randn(*dtrue.shape) self.survey.simpeg_survey.dobs = dtrue+noise self.survey.simpeg_survey.std = dtrue*0 + std
def test_nC_residual(self): # x-direction cs, ncx, ncz, npad = 1., 10., 10., 20 hx = [(cs, ncx), (cs, npad, 1.3)] # z direction npad = 12 temp = np.logspace(np.log10(1.), np.log10(12.), 19) temp_pad = temp[-1] * 1.3**np.arange(npad) hz = np.r_[temp_pad[::-1], temp[::-1], temp, temp_pad] mesh = Mesh.CylMesh([hx, 1, hz], '00C') active = mesh.vectorCCz < 0. active = mesh.vectorCCz < 0. actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap regMesh = Mesh.TensorMesh([mesh.hz[mapping.maps[-1].indActive]]) reg = Regularization.Simple(regMesh) self.assertTrue(reg._nC_residual == regMesh.nC) self.assertTrue( all([fct._nC_residual == regMesh.nC for fct in reg.objfcts]))
def setup(self): self.setup_geometry() self.set_syntetic_conductivity() self.setup_measurement() # Setup Problem with exponential mapping and Active cells only in the core mesh expmap = Maps.ExpMap(self.mesh) extrude = Maps.Surject2Dto3D(self.mesh_core, normal='Y') mapactive = Maps.InjectActiveCells(mesh=self.mesh, indActive=self.actind, valInactive=-5.) self.mapping = expmap * mapactive * extrude assert self.mapping.nP == self.mesh_core.nCx * self.mesh_core.nCz problem = DC.Problem3D_CC(self.mesh, sigmaMap=self.mapping) problem.pair(self.survey.simpeg_survey) problem.Solver = SolverLU #problem.Solver = SolverBiCG # Compute prediction using the forward model and true conductivity data. # survey.dpred(mtrue[actind]) # Make synthetic data adding a noise to the prediction. # In fact prediction is computed again. self.survey.simpeg_survey.makeSyntheticData(self.mtrue, std=0.05, force=True)
def run(plotIt=True): """ EM: FDEM: 1D: Inversion ======================= Here we will create and run a FDEM 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') 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: import matplotlib.pyplot as plt 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, mapping=mapping) try: from pymatsolver import MumpsSolver prb.Solver = MumpsSolver except ImportError, e: prb.Solver = SolverLU
def __init__(self, mesh, **kwargs): BaseSIPProblem_2D.__init__(self, mesh, **kwargs) if self.actinds is None: print("You did not put Active indices") print("So, set actMap = IdentityMap(mesh)") self.actinds = np.ones(mesh.nC, dtype=bool) self.actMap = Maps.InjectActiveCells(mesh, self.actinds, 0.)
def setUp_TDEM(prbtype='b', rxcomp='bz', waveform='stepoff'): cs = 5. ncx = 8 ncy = 8 ncz = 8 npad = 4 # hx = [(cs, ncx), (cs, npad, 1.3)] # hz = [(cs, npad, -1.3), (cs, ncy), (cs, npad, 1.3)] mesh = Mesh.TensorMesh( [ [(cs, npad, -1.3), (cs, ncx), (cs, npad, 1.3)], [(cs, npad, -1.3), (cs, ncy), (cs, npad, 1.3)], [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)] ], 'CCC' ) active = mesh.vectorCCz < 0. activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap prb = getattr(EM.TDEM, 'Problem3D_{}'.format(prbtype))(mesh, sigmaMap=mapping) rxtimes = np.logspace(-4, -3, 20) if waveform.upper() == 'RAW': out = EM.Utils.VTEMFun(prb.times, 0.00595, 0.006, 100) wavefun = interp1d(prb.times, out) t0 = 0.006 waveform = EM.TDEM.Src.RawWaveform(offTime=t0, waveFct=wavefun) prb.timeSteps = [(1e-3, 5), (1e-4, 5), (5e-5, 10), (5e-5, 10), (1e-4, 10)] rxtimes = t0+rxtimes else: waveform = EM.TDEM.Src.StepOffWaveform() prb.timeSteps = [(1e-05, 10), (5e-05, 10), (2.5e-4, 10)] rxOffset = 10. rx = getattr(EM.TDEM.Rx, 'Point_{}'.format(rxcomp[:-1]))( np.array([[rxOffset, 0., -1e-2]]), rxtimes, rxcomp[-1] ) src = EM.TDEM.Src.MagDipole( [rx], loc=np.array([0., 0., 0.]), waveform=waveform ) survey = EM.TDEM.Survey([src]) prb.Solver = Solver m = (np.log(1e-1)*np.ones(prb.sigmaMap.nP) + 1e-2*np.random.rand(prb.sigmaMap.nP)) prb.pair(survey) mesh = mesh return prb, m, mesh
def _setupDCProblem(self): expMap = Maps.ExpMap(self.mesh) inactiveCellIndices = numpy.logical_not(self.activeCellIndices) inactiveCellData = self.givenModelCond[inactiveCellIndices] mapActive = Maps.InjectActiveCells(mesh=self.mesh, indActive=self.activeCellIndices, valInactive=inactiveCellData) self.mapping = expMap * mapActive self.DCproblem = DC.Problem3D_CC(self.mesh, sigmaMap=self.mapping) self.DCproblem.pair(self.survey) self.DCproblem.Solver = Solver pass
def halfSpaceProblemAnaDiff(meshType, sig_half=1e-2, rxOffset=50., bounds=None, showIt=False): print '\nTesting sig_half = {0}, rxOffset= {1}'.format(sig_half, rxOffset) if bounds is None: bounds = [1e-5, 1e-3] if meshType == 'CYL': cs, ncx, ncz, npad = 5., 30, 10, 20 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') elif meshType == 'TENSOR': cs, nc, npad = 20., 13, 5 hx = [(cs, npad, -1.3), (cs, nc), (cs, npad, 1.3)] hy = [(cs, npad, -1.3), (cs, nc), (cs, npad, 1.3)] hz = [(cs, npad, -1.3), (cs, nc), (cs, npad, 1.3)] mesh = Mesh.TensorMesh([hx, hy, hz], 'CCC') active = mesh.vectorCCz < 0. actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap rx = EM.TDEM.RxTDEM(np.array([[rxOffset, 0., 0.]]), np.logspace(-5, -4, 21), 'bz') src = EM.TDEM.SrcTDEM_VMD_MVP([rx], loc=np.array([0., 0., 0.])) # src = EM.TDEM.SrcTDEM([rx], loc=np.array([0., 0., 0.])) survey = EM.TDEM.SurveyTDEM([src]) prb = EM.TDEM.ProblemTDEM_b(mesh, mapping=mapping) prb.Solver = MumpsSolver prb.timeSteps = [(1e-06, 40), (5e-06, 40), (1e-05, 40), (5e-05, 40), (0.0001, 40), (0.0005, 40)] sigma = np.ones(mesh.nCz)*1e-8 sigma[active] = sig_half sigma = np.log(sigma[active]) prb.pair(survey) bz_ana = mu_0*EM.Analytics.hzAnalyticDipoleT(rx.locs[0][0]+1e-3, rx.times, sig_half) bz_calc = survey.dpred(sigma) ind = np.logical_and(rx.times > bounds[0], rx.times < bounds[1]) log10diff = np.linalg.norm(np.log10(np.abs(bz_calc[ind])) - np.log10(np.abs(bz_ana[ind])))/np.linalg.norm(np.log10(np.abs(bz_ana[ind]))) print 'Difference: ', log10diff if showIt == True: plt.loglog(rx.times[bz_calc>0], bz_calc[bz_calc>0], 'r', rx.times[bz_calc<0], -bz_calc[bz_calc<0], 'r--') plt.loglog(rx.times, abs(bz_ana), 'b*') plt.title('sig_half = {0:e}'.format(sig_half)) plt.show() return log10diff
def test_activeCells(self): M = Mesh.TensorMesh([2, 4], '0C') for actMap in [Maps.InjectActiveCells(M, M.vectorCCy <= 0, 10, nC=M.nCy), Maps.ActiveCells(M, M.vectorCCy <= 0, 10, nC=M.nCy)]: vertMap = Maps.SurjectVertical1D(M) combo = vertMap * actMap m = np.r_[1., 2.] mod = Models.Model(m, combo) self.assertLess(np.linalg.norm(mod.transform - np.r_[1, 1, 2, 2, 10, 10, 10, 10.]), TOL) self.assertLess((mod.transformDeriv - combo.deriv(m)).toarray().sum(), TOL)
def setUp_TDEM(prbtype='e', rxcomp='ex'): cs = 5. ncx = 8 ncy = 8 ncz = 8 npad = 0 # hx = [(cs, ncx), (cs, npad, 1.3)] # hz = [(cs, npad, -1.3), (cs, ncy), (cs, npad, 1.3)] mesh = Mesh.TensorMesh([[ (cs, npad, -1.3), (cs, ncx), (cs, npad, 1.3) ], [(cs, npad, -1.3), (cs, ncy), (cs, npad, 1.3)], [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)]], 'CCC') # active = mesh.vectorCCz < 0. activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap rxOffset = 0. rxlocs = np.array([[20, 20., 0.]]) rxtimes = np.logspace(-4, -3, 20) rx = getattr(EM.TDEM.Rx, 'Point_{}'.format(rxcomp[:-1]))(locs=rxlocs, times=rxtimes, orientation=rxcomp[-1]) Aloc = np.r_[-10., 0., 0.] Bloc = np.r_[10., 0., 0.] srcloc = np.vstack((Aloc, Bloc)) src = EM.TDEM.Src.LineCurrent([rx], loc=srcloc, waveform=EM.TDEM.Src.StepOffWaveform()) survey = EM.TDEM.Survey([src]) prb = getattr(EM.TDEM, 'Problem3D_{}'.format(prbtype))(mesh, sigmaMap=mapping) prb.timeSteps = [(1e-05, 10), (5e-05, 10), (2.5e-4, 10)] prb.Solver = Solver m = (np.log(1e-1) * np.ones(prb.sigmaMap.nP) + 1e-3 * np.random.randn(prb.sigmaMap.nP)) prb.pair(survey) mesh = mesh return prb, m, mesh
def setup(self): self.setup_geometry() self.set_real_data_survey() #self.set_syntetic_conductivity() #self.setup_measurement() self.ln_sigback = np.log(self.survey.median_apparent_conductivity()) print("ln cond med: ", self.ln_sigback) # Setup Problem with exponential mapping and Active cells only in the core mesh expmap = Maps.ExpMap(self.mesh) mapactive = Maps.InjectActiveCells(mesh=self.mesh, indActive=self.actind, valInactive=self.ln_sigback) self.mapping = expmap * mapactive problem = DC.Problem3D_CC(self.mesh, sigmaMap=self.mapping) problem.pair(self.survey.simpeg_survey) problem.Solver = Solver
def test_activeCells(self): M = Mesh.TensorMesh([2, 4], '0C') expMap = Maps.ExpMap(M) for actMap in [ Maps.InjectActiveCells(M, M.vectorCCy <= 0, 10, nC=M.nCy), Maps.ActiveCells(M, M.vectorCCy <= 0, 10, nC=M.nCy) ]: # actMap = Maps.InjectActiveCells(M, M.vectorCCy <=0, 10, nC=M.nCy) vertMap = Maps.SurjectVertical1D(M) combo = vertMap * actMap m = np.r_[1, 2.] mod = Models.Model(m, combo) # import matplotlib.pyplot as plt # plt.colorbar(M.plotImage(mod.transform)[0]) # plt.show() self.assertLess( np.linalg.norm(mod.transform - np.r_[1, 1, 2, 2, 10, 10, 10, 10.]), TOL) self.assertLess( (mod.transformDeriv - combo.deriv(m)).toarray().sum(), TOL)
def setUp_TDEM(prbtype='b', rxcomp='bz'): cs = 5. ncx = 20 ncy = 15 npad = 20 hx = [(cs, ncx), (cs, npad, 1.3)] hy = [(cs, npad, -1.3), (cs, ncy), (cs, npad, 1.3)] mesh = Mesh.CylMesh([hx, 1, hy], '00C') # active = mesh.vectorCCz < 0. activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap rxOffset = 10. if prbtype == 'b': prb = EM.TDEM.Problem3D_b(mesh, mapping=mapping) elif prbtype == 'e': prb = EM.TDEM.Problem3D_e(mesh, mapping=mapping) prb.timeSteps = [(1e-3, 5), (1e-4, 5), (5e-5, 10), (5e-5, 10), (1e-4, 10)] out = EM.Utils.VTEMFun(prb.times, 0.00595, 0.006, 100) wavefun = interp1d(prb.times, out) t0 = 0.006 waveform = EM.TDEM.Src.RawWaveform(offTime=t0, waveFct=wavefun) timerx = np.logspace(-4, -3, 20) rx = EM.TDEM.Rx(np.array([[rxOffset, 0., 0.]]), timerx, rxcomp) src = EM.TDEM.Src.MagDipole([rx], waveform= waveform, loc=np.array([0., 0., 0.])) survey = EM.TDEM.Survey([src]) prb.Solver = Solver m = np.log(1e-1)*np.ones(prb.mapping.nP) # + 1e-2*np.random.randn(prb.mapping.nP) prb.pair(survey) mesh = mesh return prb, m, mesh
def setUp_TDEM(self, rxcomp='bz'): cs = 5. ncx = 20 ncy = 6 npad = 20 hx = [(cs, ncx), (cs, npad, 1.3)] hy = [(cs, npad, -1.3), (cs, ncy), (cs, npad, 1.3)] mesh = Mesh.CylMesh([hx, 1, hy], '00C') active = mesh.vectorCCz < 0. activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap rxOffset = 40. rx = EM.TDEM.Rx(np.array([[rxOffset, 0., 0.]]), np.logspace(-4, -3, 20), rxcomp) src = EM.TDEM.Src.MagDipole([rx], loc=np.array([0., 0., 0.])) rx2 = EM.TDEM.Rx(np.array([[rxOffset-10, 0., 0.]]), np.logspace(-5, -4, 25), rxcomp) src2 = EM.TDEM.Src.MagDipole( [rx2], loc=np.array([0., 0., 0.])) survey = EM.TDEM.Survey([src, src2]) prb = EM.TDEM.Problem3D_b(mesh, mapping=mapping) # prb.timeSteps = [1e-5] prb.timeSteps = [(1e-05, 10), (5e-05, 10), (2.5e-4, 10)] # prb.timeSteps = [(1e-05, 100)] prb.Solver = Solver m = (np.log(1e-1)*np.ones(prb.mapping.nP) + 1e-2*np.random.randn(prb.mapping.nP)) prb.pair(survey) return mesh, prb, m
def setLayerSphereParam(self, d1=6, h=6, d2=16, R=4, sig0=1e-8, sigb=1e-2, sig1=1e-1, sig2=1., chi=0.): self.z0 = 0. # Surface elevation self.z1 = self.z0 - d1 # Depth to layer self.h = h # Thickness of layer self.z2 = self.z0 - d2 # Depth to center of sphere self.R = R # Radius of sphere self.sig0 = sig0 # Air conductivity self.sigb = sigb # Background conductivity self.sig1 = sig1 # Layer conductivity self.sig2 = sig2 # Sphere conductivity active = self.mesh.gridCC[:, 2] < self.z0 ind1 = ((self.mesh.gridCC[:, 2] < self.z1) & (self.mesh.gridCC[:, 2] >= self.z1 - self.h)) ind2 = np.sqrt((self.mesh.gridCC[:, 0])**2 + (self.mesh.gridCC[:, 2] - self.z2)**2) <= self.R self.mapping = (Maps.InjectActiveCells(self.mesh, active, sig0, nC=self.mesh.nC)) model = np.ones(self.mesh.nC) * sigb model[ind1] = sig1 model[ind2] = sig2 self.m = model[active] self.mu = np.ones(self.mesh.nC) * mu_0 self.mu[self.mesh.gridCC[:, 2] < 0.] = (1. + chi) * mu_0 return self.m
def setUp_TDEM(prbtype='b', rxcomp='bz'): cs = 5. ncx = 20 ncy = 15 npad = 20 hx = [(cs, ncx), (cs, npad, 1.3)] hy = [(cs, npad, -1.3), (cs, ncy), (cs, npad, 1.3)] mesh = Mesh.CylMesh([hx, 1, hy], '00C') # active = mesh.vectorCCz < 0. activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap rxOffset = 10. rx = EM.TDEM.Rx(np.array([[rxOffset, 0., -1e-2]]), np.logspace(-4, -3, 20), rxcomp) src = EM.TDEM.Src.MagDipole([rx], loc=np.array([0., 0., 0.])) survey = EM.TDEM.Survey([src]) if prbtype == 'b': prb = EM.TDEM.Problem3D_b(mesh, mapping=mapping) elif prbtype == 'e': prb = EM.TDEM.Problem3D_e(mesh, mapping=mapping) prb.timeSteps = [(1e-05, 10), (5e-05, 10), (2.5e-4, 10)] # prb.timeSteps = [(1e-05, 10), (1e-05, 50), (1e-05, 50) ] #, (2.5e-4, 10)] prb.Solver = Solver m = (np.log(1e-1) * np.ones(prb.mapping.nP) + 1e-3 * np.random.randn(prb.mapping.nP)) prb.pair(survey) mesh = mesh return prb, m, mesh
def getProb(meshType='CYL', rxTypes='bx,bz', nSrc=1): cs = 5. ncx = 20 ncy = 6 npad = 20 hx = [(cs, ncx), (cs, npad, 1.3)] hy = [(cs, npad, -1.3), (cs, ncy), (cs, npad, 1.3)] mesh = Mesh.CylMesh([hx, 1, hy], '00C') active = mesh.vectorCCz < 0. activeMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * activeMap rxOffset = 40. srcs = [] for ii in range(nSrc): rxs = [ EM.TDEM.RxTDEM(np.array([[rxOffset, 0., 0.]]), np.logspace(-4, -3, 20 + ii), rxType) for rxType in rxTypes.split(',') ] srcs += [EM.TDEM.SrcTDEM_VMD_MVP(rxs, np.array([0., 0., 0.]))] survey = EM.TDEM.SurveyTDEM(srcs) prb = EM.TDEM.ProblemTDEM_b(mesh, mapping=mapping) # prb.timeSteps = [1e-5] prb.timeSteps = [(1e-05, 10), (5e-05, 10), (2.5e-4, 10)] # prb.timeSteps = [(1e-05, 100)] try: from pymatsolver import MumpsSolver prb.Solver = MumpsSolver except ImportError, e: prb.Solver = SolverLU
def run(runIt=False, plotIt=True, saveIt=False, saveFig=False, cleanup=True): """ Run the bookpurnong 1D stitched RESOLVE inversions. :param bool runIt: re-run the inversions? Default downloads and plots saved results :param bool plotIt: show the plots? :param bool saveIt: save the re-inverted results? :param bool saveFig: save the figure :param bool cleanup: remove the downloaded results """ # download the data downloads, directory = download_and_unzip_data() # Load resolve data resolve = h5py.File(os.path.sep.join([directory, "booky_resolve.hdf5"]), "r") river_path = resolve["river_path"][()] # River path nSounding = resolve["data"].shape[0] # the # of soundings # Bird height from surface b_height_resolve = resolve["src_elevation"][()] # fetch the frequencies we are considering cpi_inds = [0, 2, 6, 8, 10] # Indices for HCP in-phase cpq_inds = [1, 3, 7, 9, 11] # Indices for HCP quadrature frequency_cp = resolve["frequency_cp"][()] # build a mesh cs, ncx, ncz, npad = 1., 10., 10., 20 hx = [(cs, ncx), (cs, npad, 1.3)] npad = 12 temp = np.logspace(np.log10(1.), np.log10(12.), 19) temp_pad = temp[-1] * 1.3**np.arange(npad) hz = np.r_[temp_pad[::-1], temp[::-1], temp, temp_pad] mesh = Mesh.CylMesh([hx, 1, hz], '00C') active = mesh.vectorCCz < 0. # survey parameters rxOffset = 7.86 # tx-rx separation bp = -mu_0 / (4 * np.pi * rxOffset**3) # primary magnetic field # re-run the inversion if runIt: # set up the mappings - we are inverting for 1D log conductivity # below the earth's surface. actMap = Maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = Maps.ExpMap(mesh) * Maps.SurjectVertical1D(mesh) * actMap # build starting and reference model sig_half = 1e-1 sig_air = 1e-8 sigma = np.ones(mesh.nCz) * sig_air sigma[active] = sig_half m0 = np.log(1e-1) * np.ones(active.sum()) # starting model mref = np.log(1e-1) * np.ones(active.sum()) # reference model # initalize empty lists for storing inversion results mopt_re = [] # recovered model dpred_re = [] # predicted data dobs_re = [] # observed data # downsample the data for the inversion nskip = 40 # set up a noise model # 10% for the 3 lowest frequencies, 15% for the two highest std = np.repeat(np.r_[np.ones(3) * 0.1, np.ones(2) * 0.15], 2) floor = abs(20 * bp * 1e-6) # floor of 20ppm # loop over the soundings and invert each for rxind in range(nSounding): # convert data from ppm to magnetic field (A/m^2) dobs = np.c_[resolve["data"][rxind, :][cpi_inds].astype(float), resolve["data"][rxind, :][cpq_inds]. astype(float)].flatten() * bp * 1e-6 # perform the inversion src_height = b_height_resolve[rxind].astype(float) mopt, dpred, dobs = resolve_1Dinversions(mesh, dobs, src_height, frequency_cp, m0, mref, mapping, std=std, floor=floor) # add results to our list mopt_re.append(mopt) dpred_re.append(dpred) dobs_re.append(dobs) # save results mopt_re = np.vstack(mopt_re) dpred_re = np.vstack(dpred_re) dobs_re = np.vstack(dobs_re) if saveIt: np.save("mopt_re_final", mopt_re) np.save("dobs_re_final", dobs_re) np.save("dpred_re_final", dpred_re) mopt_re = resolve["mopt"][()] dobs_re = resolve["dobs"][()] dpred_re = resolve["dpred"][()] sigma = np.exp(mopt_re) indz = -7 # depth index # so that we can visually compare with literature (eg Viezzoli, 2010) cmap = "jet" # dummy figure for colobar fig = plt.figure() out = plt.scatter(np.ones(3), np.ones(3), c=np.linspace(-2, 1, 3), cmap=cmap) plt.close(fig) # plot from the paper fs = 13 # fontsize # matplotlib.rcParams['font.size'] = fs plt.figure(figsize=(13, 7)) ax0 = plt.subplot2grid((2, 3), (0, 0), rowspan=2, colspan=2) ax1 = plt.subplot2grid((2, 3), (0, 2)) ax2 = plt.subplot2grid((2, 3), (1, 2)) # titles of plots title = [("(a) Recovered model, %.1f m depth") % (-mesh.vectorCCz[active][indz]), "(b) Obs (Real 400 Hz)", "(c) Pred (Real 400 Hz)"] temp = sigma[:, indz] tree = cKDTree(list(zip(resolve["xy"][:, 0], resolve["xy"][:, 1]))) d, d_inds = tree.query(list(zip(resolve["xy"][:, 0], resolve["xy"][:, 1])), k=20) w = 1. / (d + 100.)**2. w = Utils.sdiag(1. / np.sum(w, axis=1)) * (w) xy = resolve["xy"] temp = (temp.flatten()[d_inds] * w).sum(axis=1) Utils.plot2Ddata(xy, temp, ncontour=100, scale="log", dataloc=False, contourOpts={ "cmap": cmap, "vmin": 1e-2, "vmax": 1e1 }, ax=ax0) ax0.plot(resolve["xy"][:, 0], resolve["xy"][:, 1], 'k.', alpha=0.02, ms=1) cb = plt.colorbar(out, ax=ax0, ticks=np.linspace(-2, 1, 4), format="$10^{%.1f}$") cb.set_ticklabels(["0.01", "0.1", "1", "10"]) cb.set_label("Conductivity (S/m)") ax0.plot(river_path[:, 0], river_path[:, 1], 'k-', lw=0.5) # plot observed and predicted data freq_ind = 0 axs = [ax1, ax2] temp_dobs = dobs_re[:, freq_ind].copy() ax1.plot(river_path[:, 0], river_path[:, 1], 'k-', lw=0.5) out = Utils.plot2Ddata(resolve["xy"][()], temp_dobs / abs(bp) * 1e6, ncontour=100, scale="log", dataloc=False, ax=ax1, contourOpts={"cmap": "viridis"}) vmin, vmax = out[0].get_clim() cb = plt.colorbar(out[0], ticks=np.linspace(vmin, vmax, 3), ax=ax1, format="%.1e", fraction=0.046, pad=0.04) cb.set_label("Bz (ppm)") temp_dpred = dpred_re[:, freq_ind].copy() # temp_dpred[mask_:_data] = np.nan ax2.plot(river_path[:, 0], river_path[:, 1], 'k-', lw=0.5) Utils.plot2Ddata(resolve["xy"][()], temp_dpred / abs(bp) * 1e6, ncontour=100, scale="log", dataloc=False, contourOpts={ "vmin": 10**vmin, "vmax": 10**vmax, "cmap": "viridis" }, ax=ax2) cb = plt.colorbar(out[0], ticks=np.linspace(vmin, vmax, 3), ax=ax2, format="%.1e", fraction=0.046, pad=0.04) cb.set_label("Bz (ppm)") for i, ax in enumerate([ax0, ax1, ax2]): xticks = [460000, 463000] yticks = [6195000, 6198000, 6201000] xloc, yloc = 462100.0, 6196500.0 ax.set_xticks(xticks) ax.set_yticks(yticks) # ax.plot(xloc, yloc, 'wo') ax.plot(river_path[:, 0], river_path[:, 1], 'k', lw=0.5) ax.set_aspect("equal") ax.plot(resolve["xy"][:, 0], resolve["xy"][:, 1], 'k.', alpha=0.02, ms=1) ax.set_yticklabels([str(f) for f in yticks]) ax.set_ylabel("Northing (m)") ax.set_xlabel("Easting (m)") ax.set_title(title[i]) plt.tight_layout() if plotIt: plt.show() if saveFig is True: fig.savefig("obspred_resolve.png", dpi=200) resolve.close() if cleanup: os.remove(downloads) shutil.rmtree(directory)
# Get the indicies of the magnetized block ind = Utils.ModelBuilder.getIndicesBlock( np.r_[-20, -20, -10], np.r_[20, 20, 25], mesh.gridCC, )[0] # Assign magnetization values model[ind, :] = np.kron(np.ones((ind.shape[0], 1)), M_xyz * 0.05) # Remove air cells model = model[actv, :] # Create active map to go from reduce set to full actvMap = Maps.InjectActiveCells(mesh, actv, np.nan) # Creat reduced identity map idenMap = Maps.IdentityMap(nP=nC * 3) # Create the forward model operator prob = PF.Magnetics.MagneticIntegral(mesh, chiMap=idenMap, actInd=actv, modelType='vector') # Pair the survey and problem survey.pair(prob) # Compute some data and add some random noise data = prob.fields(Utils.mkvc(model))
def setUp(self): np.random.seed(0) # Define the inducing field parameter H0 = (50000, 90, 0) # Create a mesh dx = 5. hxind = [(dx, 5, -1.3), (dx, 5), (dx, 5, 1.3)] hyind = [(dx, 5, -1.3), (dx, 5), (dx, 5, 1.3)] hzind = [(dx, 5, -1.3), (dx, 6)] mesh = Mesh.TensorMesh([hxind, hyind, hzind], 'CCC') # Get index of the center midx = int(mesh.nCx / 2) midy = int(mesh.nCy / 2) # Lets create a simple Gaussian topo and set the active cells [xx, yy] = np.meshgrid(mesh.vectorNx, mesh.vectorNy) zz = -np.exp((xx**2 + yy**2) / 75**2) + mesh.vectorNz[-1] # Go from topo to actv cells topo = np.c_[Utils.mkvc(xx), Utils.mkvc(yy), Utils.mkvc(zz)] actv = Utils.surface2ind_topo(mesh, topo, 'N') actv = np.asarray([inds for inds, elem in enumerate(actv, 1) if elem], dtype=int) - 1 # Create active map to go from reduce space to full actvMap = Maps.InjectActiveCells(mesh, actv, -100) nC = len(actv) # Create and array of observation points xr = np.linspace(-20., 20., 20) yr = np.linspace(-20., 20., 20) X, Y = np.meshgrid(xr, yr) # Move the observation points 5m above the topo Z = -np.exp((X**2 + Y**2) / 75**2) + mesh.vectorNz[-1] + 5. # Create a MAGsurvey rxLoc = np.c_[Utils.mkvc(X.T), Utils.mkvc(Y.T), Utils.mkvc(Z.T)] rxLoc = PF.BaseMag.RxObs(rxLoc) srcField = PF.BaseMag.SrcField([rxLoc], param=H0) survey = PF.BaseMag.LinearSurvey(srcField) # We can now create a susceptibility model and generate data # Here a simple block in half-space model = np.zeros((mesh.nCx, mesh.nCy, mesh.nCz)) model[(midx - 2):(midx + 2), (midy - 2):(midy + 2), -6:-2] = 0.02 model = Utils.mkvc(model) self.model = model[actv] # Create active map to go from reduce set to full actvMap = Maps.InjectActiveCells(mesh, actv, -100) # Creat reduced identity map idenMap = Maps.IdentityMap(nP=nC) # Create the forward model operator prob = PF.Magnetics.MagneticIntegral(mesh, chiMap=idenMap, actInd=actv) # Pair the survey and problem survey.pair(prob) # Compute linear forward operator and compute some data d = prob.fields(self.model) # Add noise and uncertainties (1nT) data = d + np.random.randn(len(d)) wd = np.ones(len(data)) * 1. survey.dobs = data survey.std = wd # Create sensitivity weights from our linear forward operator wr = np.sum(prob.G**2., axis=0)**0.5 wr = (wr / np.max(wr)) # Create a regularization reg = Regularization.Sparse(mesh, indActive=actv, mapping=idenMap) reg.cell_weights = wr reg.norms = np.c_[0, 0, 0, 0] reg.gradientType = 'component' # reg.eps_p, reg.eps_q = 1e-3, 1e-3 # Data misfit function dmis = DataMisfit.l2_DataMisfit(survey) dmis.W = 1 / wd # Add directives to the inversion opt = Optimization.ProjectedGNCG(maxIter=100, lower=0., upper=1., maxIterLS=20, maxIterCG=10, tolCG=1e-3) invProb = InvProblem.BaseInvProblem(dmis, reg, opt) betaest = Directives.BetaEstimate_ByEig() # Here is where the norms are applied IRLS = Directives.Update_IRLS(f_min_change=1e-4, minGNiter=1) update_Jacobi = Directives.UpdatePreconditioner() self.inv = Inversion.BaseInversion( invProb, directiveList=[IRLS, betaest, update_Jacobi])
import os cur_dir = "D:/Seogi/Dropbox/Researches/AEM_workshow_2018_simpeg/2d_inv_warm_start" os.chdir(cur_dir) cs, ncx, ncy, ncz, = 50., 20, 1, 20 npad_x, npad_y, npad_z = 10, 10, 10 pad_rate = 1.3 hx = [(cs, npad_x, -pad_rate), (cs, ncx), (cs, npad_x, pad_rate)] hy = [(cs, npad_y, -pad_rate), (cs, ncy), (cs, npad_y, pad_rate)] hz = [(cs, npad_z, -pad_rate), (cs, ncz), (cs, npad_z, pad_rate)] mesh_3d = Mesh.TensorMesh([hx, hy, hz], 'CCC') mesh_2d = Mesh.TensorMesh([hx, hz], 'CC') actind = mesh_2d.gridCC[:, 1] < 0. map_2Dto3D = Maps.Surject2Dto3D(mesh_3d) expmap = Maps.ExpMap(mesh_2d) actmap = Maps.InjectActiveCells(mesh_2d, indActive=actind, valInactive=np.log(1e-8)) mapping = map_2Dto3D * expmap * actmap x = mesh_3d.vectorCCx[np.logical_and(mesh_3d.vectorCCx > -450, mesh_3d.vectorCCx < 450)] time = np.logspace(np.log10(5e-5), np.log10(2.5e-3), 21) ind_start = 19 dobs = np.load('../dobs.npy') DOBS = dobs.reshape((x.size, 2, time.size))[:, :, ind_start:] dobs_dbdtz = DOBS[:, 0, :].flatten() dobs_dbdtx = DOBS[:, 1, :].flatten() #%% import os model = [] for File in os.listdir("."):
zmin, zmax = 0, 0 endl = np.array([[xmin, ymin, zmin], [xmax, ymax, zmax]]) survey3 = DCUtils.gen_DCIPsurvey(endl, "dipole-dipole", dim=mesh.dim, a=3, b=3, n=8) # Concatenate lines survey = DC.Survey(survey1.srcList + survey2.srcList + survey3.srcList) # Setup Problem with exponential mapping and Active cells only in the core mesh expmap = Maps.ExpMap(mesh) mapactive = Maps.InjectActiveCells(mesh=mesh, indActive=actind, valInactive=-5.) mapping = expmap * mapactive problem = DC.Problem3D_CC(mesh, sigmaMap=mapping) problem.pair(survey) problem.Solver = Solver survey.dpred(mtrue[actind]) survey.makeSyntheticData(mtrue[actind], std=0.05, force=True) # Tikhonov Inversion #################### # Initial Model m0 = np.median(ln_sigback) * np.ones(mapping.nP) # Data Misfit