def simulate(self, srcLoc, rxLoc, time, radius=1.0): bz = tdem.receivers.PointMagneticFluxDensity(rxLoc, time, orientation="z") # dbzdt = EM.TDEM.Rx.Point_dbdt(rxLoc, time, orientation="z") src = tdem.sources.CircularLoop( [bz], waveform=tdem.sources.StepOffWaveform(), location=srcLoc, radius=radius) self.srcList = [src] survey = tdem.survey.Survey(self.srcList) sim = tdem.Simulation3DMagneticFluxDensity(self.mesh, survey=survey, sigmaMap=self.mapping) sim.time_steps = [ (1e-06, 10), (5e-06, 10), (1e-05, 10), (5e-5, 10), (1e-4, 10), (5e-4, 10), (1e-3, 10), ] self.f = sim.fields(self.m) self.sim = sim dpred = sim.dpred(self.m, f=self.f) return dpred
def run(plotIt=True, saveFig=False): # Set up cylindrically symmeric mesh cs, ncx, ncz, npad = 10.0, 15, 25, 13 # padded cyl mesh hx = [(cs, ncx), (cs, npad, 1.3)] hz = [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)] mesh = discretize.CylMesh([hx, 1, hz], "00C") # Conductivity model layerz = np.r_[-200.0, -100.0] layer = (mesh.vectorCCz >= layerz[0]) & (mesh.vectorCCz <= layerz[1]) active = mesh.vectorCCz < 0.0 sig_half = 1e-2 # Half-space conductivity sig_air = 1e-8 # Air conductivity sig_layer = 5e-2 # Layer conductivity sigma = np.ones(mesh.nCz) * sig_air sigma[active] = sig_half sigma[layer] = sig_layer # Mapping actMap = maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = maps.ExpMap(mesh) * maps.SurjectVertical1D(mesh) * actMap mtrue = np.log(sigma[active]) # ----- FDEM problem & survey ----- # rxlocs = utils.ndgrid([np.r_[50.0], np.r_[0], np.r_[0.0]]) bzr = FDEM.Rx.PointMagneticFluxDensitySecondary(rxlocs, "z", "real") bzi = FDEM.Rx.PointMagneticFluxDensitySecondary(rxlocs, "z", "imag") freqs = np.logspace(2, 3, 5) srcLoc = np.array([0.0, 0.0, 0.0]) print( "min skin depth = ", 500.0 / np.sqrt(freqs.max() * sig_half), "max skin depth = ", 500.0 / np.sqrt(freqs.min() * sig_half), ) print( "max x ", mesh.vectorCCx.max(), "min z ", mesh.vectorCCz.min(), "max z ", mesh.vectorCCz.max(), ) source_list = [ FDEM.Src.MagDipole([bzr, bzi], freq, srcLoc, orientation="Z") for freq in freqs ] surveyFD = FDEM.Survey(source_list) prbFD = FDEM.Simulation3DMagneticFluxDensity( mesh, survey=surveyFD, sigmaMap=mapping, solver=Solver ) rel_err = 0.03 dataFD = prbFD.make_synthetic_data(mtrue, relative_error=rel_err, add_noise=True) dataFD.noise_floor = np.linalg.norm(dataFD.dclean) * 1e-5 # FDEM inversion np.random.seed(1) dmisfit = data_misfit.L2DataMisfit(simulation=prbFD, data=dataFD) regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]]) reg = regularization.Simple(regMesh) opt = optimization.InexactGaussNewton(maxIterCG=10) invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt) # Inversion Directives beta = directives.BetaSchedule(coolingFactor=4, coolingRate=3) betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.0, seed=518936) target = directives.TargetMisfit() directiveList = [beta, betaest, target] inv = inversion.BaseInversion(invProb, directiveList=directiveList) m0 = np.log(np.ones(mtrue.size) * sig_half) reg.alpha_s = 5e-1 reg.alpha_x = 1.0 prbFD.counter = opt.counter = utils.Counter() opt.remember("xc") moptFD = inv.run(m0) # TDEM problem times = np.logspace(-4, np.log10(2e-3), 10) print( "min diffusion distance ", 1.28 * np.sqrt(times.min() / (sig_half * mu_0)), "max diffusion distance ", 1.28 * np.sqrt(times.max() / (sig_half * mu_0)), ) rx = TDEM.Rx.PointMagneticFluxDensity(rxlocs, times, "z") src = TDEM.Src.MagDipole( [rx], waveform=TDEM.Src.StepOffWaveform(), location=srcLoc, # same src location as FDEM problem ) surveyTD = TDEM.Survey([src]) prbTD = TDEM.Simulation3DMagneticFluxDensity( mesh, survey=surveyTD, sigmaMap=mapping, solver=Solver ) prbTD.time_steps = [(5e-5, 10), (1e-4, 10), (5e-4, 10)] rel_err = 0.03 dataTD = prbTD.make_synthetic_data(mtrue, relative_error=rel_err, add_noise=True) dataTD.noise_floor = np.linalg.norm(dataTD.dclean) * 1e-5 # TDEM inversion dmisfit = data_misfit.L2DataMisfit(simulation=prbTD, data=dataTD) regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]]) reg = regularization.Simple(regMesh) opt = optimization.InexactGaussNewton(maxIterCG=10) invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt) # directives beta = directives.BetaSchedule(coolingFactor=4, coolingRate=3) betaest = directives.BetaEstimate_ByEig(beta0_ratio=1.0, seed=518936) target = directives.TargetMisfit() directiveList = [beta, betaest, target] inv = inversion.BaseInversion(invProb, directiveList=directiveList) m0 = np.log(np.ones(mtrue.size) * sig_half) reg.alpha_s = 5e-1 reg.alpha_x = 1.0 prbTD.counter = opt.counter = utils.Counter() opt.remember("xc") moptTD = inv.run(m0) # Plot the results if plotIt: plt.figure(figsize=(10, 8)) ax0 = plt.subplot2grid((2, 2), (0, 0), rowspan=2) ax1 = plt.subplot2grid((2, 2), (0, 1)) ax2 = plt.subplot2grid((2, 2), (1, 1)) fs = 13 # fontsize matplotlib.rcParams["font.size"] = fs # Plot the model # z_true = np.repeat(mesh.vectorCCz[active][1:], 2, axis=0) # z_true = np.r_[mesh.vectorCCz[active][0], z_true, mesh.vectorCCz[active][-1]] activeN = mesh.vectorNz <= 0.0 + cs / 2.0 z_true = np.repeat(mesh.vectorNz[activeN][1:-1], 2, axis=0) z_true = np.r_[mesh.vectorNz[activeN][0], z_true, mesh.vectorNz[activeN][-1]] sigma_true = np.repeat(sigma[active], 2, axis=0) ax0.semilogx(sigma_true, z_true, "k-", lw=2, label="True") ax0.semilogx( np.exp(moptFD), mesh.vectorCCz[active], "bo", ms=6, markeredgecolor="k", markeredgewidth=0.5, label="FDEM", ) ax0.semilogx( np.exp(moptTD), mesh.vectorCCz[active], "r*", ms=10, markeredgecolor="k", markeredgewidth=0.5, label="TDEM", ) ax0.set_ylim(-700, 0) ax0.set_xlim(5e-3, 1e-1) ax0.set_xlabel("Conductivity (S/m)", fontsize=fs) ax0.set_ylabel("Depth (m)", fontsize=fs) ax0.grid(which="both", color="k", alpha=0.5, linestyle="-", linewidth=0.2) ax0.legend(fontsize=fs, loc=4) # plot the data misfits - negative b/c we choose positive to be in the # direction of primary ax1.plot(freqs, -dataFD.dobs[::2], "k-", lw=2, label="Obs (real)") ax1.plot(freqs, -dataFD.dobs[1::2], "k--", lw=2, label="Obs (imag)") dpredFD = prbFD.dpred(moptTD) ax1.loglog( freqs, -dpredFD[::2], "bo", ms=6, markeredgecolor="k", markeredgewidth=0.5, label="Pred (real)", ) ax1.loglog( freqs, -dpredFD[1::2], "b+", ms=10, markeredgewidth=2.0, label="Pred (imag)" ) ax2.loglog(times, dataTD.dobs, "k-", lw=2, label="Obs") ax2.loglog( times, prbTD.dpred(moptTD), "r*", ms=10, markeredgecolor="k", markeredgewidth=0.5, label="Pred", ) ax2.set_xlim(times.min() - 1e-5, times.max() + 1e-4) # Labels, gridlines, etc ax2.grid(which="both", alpha=0.5, linestyle="-", linewidth=0.2) ax1.grid(which="both", alpha=0.5, linestyle="-", linewidth=0.2) ax1.set_xlabel("Frequency (Hz)", fontsize=fs) ax1.set_ylabel("Vertical magnetic field (-T)", fontsize=fs) ax2.set_xlabel("Time (s)", fontsize=fs) ax2.set_ylabel("Vertical magnetic field (T)", fontsize=fs) ax2.legend(fontsize=fs, loc=3) ax1.legend(fontsize=fs, loc=3) ax1.set_xlim(freqs.max() + 1e2, freqs.min() - 1e1) ax0.set_title("(a) Recovered Models", fontsize=fs) ax1.set_title("(b) FDEM observed vs. predicted", fontsize=fs) ax2.set_title("(c) TDEM observed vs. predicted", fontsize=fs) plt.tight_layout(pad=1.5) if saveFig is True: plt.savefig("example1.png", dpi=600)
loc=np.r_[0.0, 0.0, 0.0], orientation="z", radius=100, waveform=quarter_sine) src_list_magnetostatic = [src_magnetostatic] src_list_ramp_on = [src_ramp_on] ############################################################################### # Create the simulations # ---------------------- # # To simulate magnetic flux data, we use the b-formulation of Maxwell's # equations prob_magnetostatic = TDEM.Simulation3DMagneticFluxDensity( mesh=mesh, sigmaMap=maps.IdentityMap(mesh), timeSteps=ramp, Solver=Pardiso) prob_ramp_on = TDEM.Simulation3DMagneticFluxDensity( mesh=mesh, sigmaMap=maps.IdentityMap(mesh), timeSteps=ramp, Solver=Pardiso) survey_magnetostatic = TDEM.Survey(srcList=src_list_magnetostatic) survey_ramp_on = TDEM.Survey(src_list_ramp_on) prob_magnetostatic.pair(survey_magnetostatic) prob_ramp_on.pair(survey_ramp_on) ############################################################################### # Run the long on-time simulation # ------------------------------- t = time.time() print("--- Running Long On-Time Simulation ---")
def test_permeable_sources(self): target_mur = self.target_mur target_l = self.target_l target_r = self.target_r sigma_back = self.sigma_back model_names = self.model_names mesh = self.mesh radius_loop = self.radius_loop # Assign physical properties on the mesh def populate_target(mur): mu_model = np.ones(mesh.nC) x_inds = mesh.gridCC[:, 0] < target_r z_inds = (mesh.gridCC[:, 2] <= 0) & (mesh.gridCC[:, 2] >= -target_l) mu_model[x_inds & z_inds] = mur return mu_0 * mu_model mu_dict = { key: populate_target(mu) for key, mu in zip(model_names, target_mur) } sigma = np.ones(mesh.nC) * sigma_back # Plot the models if plotIt: xlim = np.r_[-200, 200] # x-limits in meters zlim = np.r_[-1.5 * target_l, 10.0] # z-limits in meters. (z-positive up) fig, ax = plt.subplots(1, len(model_names), figsize=(6 * len(model_names), 5)) if len(model_names) == 1: ax = [ax] for a, key in zip(ax, model_names): plt.colorbar( mesh.plotImage( mu_dict[key], ax=a, pcolorOpts={"norm": LogNorm()}, # plot on a log-scale mirror=True, )[0], ax=a, ) a.set_title("{}".format(key), fontsize=13) # cylMeshGen.mesh.plotGrid(ax=a, slice='theta') # uncomment to plot the mesh on top of this a.set_xlim(xlim) a.set_ylim(zlim) plt.tight_layout() plt.show() ramp = [ (1e-5, 20), (1e-4, 20), (3e-4, 20), (1e-3, 20), (3e-3, 20), (1e-2, 20), (3e-2, 20), (1e-1, 20), (3e-1, 20), (1, 50), ] time_steps = ramp time_mesh = discretize.TensorMesh([ramp]) offTime = 10000 waveform = tdem.Src.QuarterSineRampOnWaveform(ramp_on=np.r_[1e-4, 20], ramp_off=offTime - np.r_[1e-4, 0]) if plotIt: wave = np.r_[[waveform.eval(t) for t in time_mesh.gridN]] plt.plot(time_mesh.gridN, wave) plt.plot(time_mesh.gridN, np.zeros(time_mesh.nN), "-|", color="k") plt.show() src_magnetostatic = tdem.Src.CircularLoop( [], location=np.r_[0.0, 0.0, 0.0], orientation="z", radius=100, ) src_ramp_on = tdem.Src.CircularLoop( [], location=np.r_[0.0, 0.0, 0.0], orientation="z", radius=100, waveform=waveform, ) src_list = [src_magnetostatic] src_list_late_ontime = [src_ramp_on] survey = tdem.Survey(source_list=src_list) survey_late_ontime = tdem.Survey(src_list_late_ontime) prob = tdem.Simulation3DMagneticFluxDensity( mesh=mesh, survey=survey, time_steps=time_steps, sigmaMap=maps.IdentityMap(mesh), solver=Pardiso, ) prob_late_ontime = tdem.Simulation3DMagneticFluxDensity( mesh=mesh, survey=survey_late_ontime, time_steps=time_steps, sigmaMap=maps.IdentityMap(mesh), solver=Pardiso, ) fields_dict = {} for key in model_names: t = time.time() print("--- Running {} ---".format(key)) prob_late_ontime.mu = mu_dict[key] fields_dict[key] = prob_late_ontime.fields(sigma) print(" ... done. Elapsed time {}".format(time.time() - t)) print("\n") b_magnetostatic = {} b_late_ontime = {} for key in model_names: prob.mu = mu_dict[key] prob.sigma = sigma b_magnetostatic[key] = src_magnetostatic.bInitial(prob) prob_late_ontime.mu = mu_dict[key] b_late_ontime[key] = utils.mkvc(fields_dict[key][:, "b", -1]) if plotIt: fig, ax = plt.subplots(len(model_names), 2, figsize=(3 * len(model_names), 5)) for i, key in enumerate(model_names): ax[i][0].semilogy(np.absolute(b_magnetostatic[key]), label="magnetostatic") ax[i][0].semilogy(np.absolute(b_late_ontime[key]), label="late on-time") ax[i][0].legend() ax[i][1].semilogy( np.absolute(b_magnetostatic[key] - b_late_ontime[key])) plt.tight_layout() plt.show() print("Testing TDEM with permeable targets") passed = [] for key in model_names: norm_magneotstatic = np.linalg.norm(b_magnetostatic[key]) norm_late_ontime = np.linalg.norm(b_late_ontime[key]) norm_diff = np.linalg.norm(b_magnetostatic[key] - b_late_ontime[key]) passed_test = (norm_diff / (0.5 * (norm_late_ontime + norm_magneotstatic)) < TOL) print("\n{}".format(key)) print("||magnetostatic||: {:1.2e}, " "||late on-time||: {:1.2e}, " "||difference||: {:1.2e} passed?: {}".format( norm_magneotstatic, norm_late_ontime, norm_diff, passed_test)) passed += [passed_test] assert all(passed) prob.sigma = 1e-4 * np.ones(mesh.nC) v = utils.mkvc(np.random.rand(mesh.nE)) w = utils.mkvc(np.random.rand(mesh.nF)) assert np.all( mesh.getEdgeInnerProduct(1e-4 * np.ones(mesh.nC)) * v == prob.MeSigma * v) assert np.all( mesh.getEdgeInnerProduct(1e-4 * np.ones(mesh.nC), invMat=True) * v == prob.MeSigmaI * v) assert np.all( mesh.getFaceInnerProduct(1.0 / 1e-4 * np.ones(mesh.nC)) * w == prob.MfRho * w) assert np.all( mesh.getFaceInnerProduct(1.0 / 1e-4 * np.ones(mesh.nC), invMat=True) * w == prob.MfRhoI * w) prob.rho = 1.0 / 1e-3 * np.ones(mesh.nC) v = utils.mkvc(np.random.rand(mesh.nE)) w = utils.mkvc(np.random.rand(mesh.nF)) assert np.all( mesh.getEdgeInnerProduct(1e-3 * np.ones(mesh.nC)) * v == prob.MeSigma * v) assert np.all( mesh.getEdgeInnerProduct(1e-3 * np.ones(mesh.nC), invMat=True) * v == prob.MeSigmaI * v) assert np.all( mesh.getFaceInnerProduct(1.0 / 1e-3 * np.ones(mesh.nC)) * w == prob.MfRho * w) assert np.all( mesh.getFaceInnerProduct(1.0 / 1e-3 * np.ones(mesh.nC), invMat=True) * w == prob.MfRhoI * w)
def run(plotIt=True): cs, ncx, ncz, npad = 5.0, 25, 24, 15 hx = [(cs, ncx), (cs, npad, 1.3)] hz = [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)] mesh = discretize.CylMesh([hx, 1, hz], "00C") active = mesh.vectorCCz < 0.0 layer = (mesh.vectorCCz < -50.0) & (mesh.vectorCCz >= -150.0) actMap = maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = maps.ExpMap(mesh) * maps.SurjectVertical1D(mesh) * actMap sig_half = 1e-3 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]) x = np.r_[30, 50, 70, 90] rxloc = np.c_[x, x * 0.0, np.zeros_like(x)] prb = TDEM.Simulation3DMagneticFluxDensity(mesh, sigmaMap=mapping, solver=Solver) prb.time_steps = [ (1e-3, 5), (1e-4, 5), (5e-5, 10), (5e-5, 5), (1e-4, 10), (5e-4, 10), ] # Use VTEM waveform out = EMutils.VTEMFun(prb.times, 0.00595, 0.006, 100) # Forming function handle for waveform using 1D linear interpolation wavefun = interp1d(prb.times, out) t0 = 0.006 waveform = TDEM.Src.RawWaveform(offTime=t0, waveFct=wavefun) rx = TDEM.Rx.PointMagneticFluxTimeDerivative( rxloc, np.logspace(-4, -2.5, 11) + t0, "z") src = TDEM.Src.CircularLoop([rx], waveform=waveform, loc=np.array([0.0, 0.0, 0.0]), radius=10.0) survey = TDEM.Survey([src]) prb.survey = survey # create observed data data = prb.make_synthetic_data(mtrue, relative_error=0.02, noise_floor=1e-11) dmisfit = data_misfit.L2DataMisfit(simulation=prb, data=data) regMesh = discretize.TensorMesh([mesh.hz[mapping.maps[-1].indActive]]) reg = regularization.Simple(regMesh) opt = optimization.InexactGaussNewton(maxIter=5, LSshorten=0.5) invProb = inverse_problem.BaseInvProblem(dmisfit, reg, opt) target = directives.TargetMisfit() # Create an inversion object beta = directives.BetaSchedule(coolingFactor=1.0, coolingRate=2.0) betaest = directives.BetaEstimate_ByEig(beta0_ratio=1e0) invProb.beta = 1e2 inv = inversion.BaseInversion(invProb, directiveList=[beta, target]) m0 = np.log(np.ones(mtrue.size) * sig_half) prb.counter = opt.counter = utils.Counter() opt.remember("xc") mopt = inv.run(m0) if plotIt: fig, ax = plt.subplots(1, 2, figsize=(10, 6)) Dobs = data.dobs.reshape((len(rx.times), len(x))) Dpred = invProb.dpred.reshape((len(rx.times), len(x))) for i in range(len(x)): ax[0].loglog(rx.times - t0, -Dobs[:, i].flatten(), "k") ax[0].loglog(rx.times - t0, -Dpred[:, i].flatten(), "k.") if i == 0: ax[0].legend(("$d^{obs}$", "$d^{pred}$"), fontsize=16) ax[0].set_xlabel("Time (s)", fontsize=14) ax[0].set_ylabel("$db_z / dt$ (nT/s)", fontsize=16) ax[0].set_xlabel("Time (s)", fontsize=14) ax[0].grid(color="k", alpha=0.5, linestyle="dashed", linewidth=0.5) plt.semilogx(sigma[active], mesh.vectorCCz[active]) plt.semilogx(np.exp(mopt), mesh.vectorCCz[active]) ax[1].set_ylim(-600, 0) ax[1].set_xlim(1e-4, 1e-1) ax[1].set_xlabel("Conductivity (S/m)", fontsize=14) ax[1].set_ylabel("Depth (m)", fontsize=14) ax[1].grid(color="k", alpha=0.5, linestyle="dashed", linewidth=0.5) plt.legend(["$\sigma_{true}$", "$\sigma_{pred}$"])
def halfSpaceProblemAnaDiff( meshType, srctype="MagDipole", sig_half=1e-2, rxOffset=50.0, bounds=None, plotIt=False, rxType="MagneticFluxDensityz", ): if bounds is None: bounds = [1e-5, 1e-3] if meshType == "CYL": cs, ncx, ncz, npad = 15.0, 30, 10, 15 hx = [(cs, ncx), (cs, npad, 1.3)] hz = [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)] mesh = discretize.CylMesh([hx, 1, hz], "00C") elif meshType == "TENSOR": cs, nc, npad = 20.0, 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 = discretize.TensorMesh([hx, hy, hz], "CCC") active = mesh.vectorCCz < 0.0 actMap = maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = maps.ExpMap(mesh) * maps.SurjectVertical1D(mesh) * actMap prb = tdem.Simulation3DMagneticFluxDensity(mesh, sigmaMap=mapping) prb.Solver = Solver prb.timeSteps = [(1e-3, 5), (1e-4, 5), (5e-5, 10), (5e-5, 10), (1e-4, 10)] out = utils.VTEMFun(prb.times, 0.00595, 0.006, 100) wavefun = interp1d(prb.times, out) t0 = 0.006 waveform = tdem.Src.RawWaveform(offTime=t0, waveFct=wavefun) rx = getattr(tdem.Rx, "Point{}".format(rxType[:-1]))(np.array([[rxOffset, 0.0, 0.0]]), np.logspace(-4, -3, 31) + t0, rxType[-1]) if srctype == "MagDipole": src = tdem.Src.MagDipole([rx], waveform=waveform, loc=np.array([0, 0.0, 0.0])) elif srctype == "CircularLoop": src = tdem.Src.CircularLoop([rx], waveform=waveform, loc=np.array([0.0, 0.0, 0.0]), radius=13.0) survey = tdem.Survey([src]) prb.pair(survey) sigma = np.ones(mesh.nCz) * 1e-8 sigma[active] = sig_half sigma = np.log(sigma[active]) if srctype == "MagDipole": bz_ana = mu_0 * analytics.hzAnalyticDipoleT(rx.locations[0][0] + 1e-3, rx.times - t0, sig_half) elif srctype == "CircularLoop": bz_ana = mu_0 * analytics.hzAnalyticCentLoopT(13, rx.times - t0, sig_half) bz_calc = prb.dpred(sigma) ind = np.logical_and(rx.times - t0 > bounds[0], rx.times - t0 < 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(" |bz_ana| = {ana} |bz_num| = {num} |bz_ana-bz_num| = {diff}".format( ana=np.linalg.norm(bz_ana), num=np.linalg.norm(bz_calc), diff=np.linalg.norm(bz_ana - bz_calc), )) print("Difference: {}".format(log10diff)) if plotIt is True: plt.loglog( rx.times[bz_calc > 0] - t0, bz_calc[bz_calc > 0], "r", rx.times[bz_calc < 0] - t0, -bz_calc[bz_calc < 0], "r--", ) plt.loglog(rx.times - t0, abs(bz_ana), "b*") plt.title("sig_half = {:e}".format(sig_half)) plt.show() return log10diff
def halfSpaceProblemAnaDiff( meshType, srctype="MagDipole", sig_half=1e-2, rxOffset=50.0, bounds=None, plotIt=False, rxType="MagneticFluxDensityz", ): if bounds is None: bounds = [1e-5, 1e-3] if meshType == "CYL": cs, ncx, ncz, npad = 5.0, 30, 10, 15 hx = [(cs, ncx), (cs, npad, 1.3)] hz = [(cs, npad, -1.3), (cs, ncz), (cs, npad, 1.3)] mesh = discretize.CylMesh([hx, 1, hz], "00C") elif meshType == "TENSOR": cs, nc, npad = 20.0, 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 = discretize.TensorMesh([hx, hy, hz], "CCC") active = mesh.vectorCCz < 0.0 actMap = maps.InjectActiveCells(mesh, active, np.log(1e-8), nC=mesh.nCz) mapping = maps.ExpMap(mesh) * maps.SurjectVertical1D(mesh) * actMap rx = getattr(tdem.Rx, "Point{}".format(rxType[:-1]))(np.array([[rxOffset, 0.0, 0.0]]), np.logspace(-5, -4, 21), rxType[-1]) if srctype == "MagDipole": src = tdem.Src.MagDipole( [rx], waveform=tdem.Src.StepOffWaveform(), location=np.array([0.0, 0.0, 0.0]), ) elif srctype == "CircularLoop": src = tdem.Src.CircularLoop( [rx], waveform=tdem.Src.StepOffWaveform(), location=np.array([0.0, 0.0, 0.0]), radius=0.1, ) survey = tdem.Survey([src]) time_steps = [ (1e-06, 40), (5e-06, 40), (1e-05, 40), (5e-05, 40), (0.0001, 40), (0.0005, 40), ] prb = tdem.Simulation3DMagneticFluxDensity(mesh, survey=survey, time_steps=time_steps, sigmaMap=mapping) prb.solver = Solver sigma = np.ones(mesh.nCz) * 1e-8 sigma[active] = sig_half sigma = np.log(sigma[active]) if srctype == "MagDipole": bz_ana = mu_0 * analytics.hzAnalyticDipoleT(rx.locations[0][0] + 1e-3, rx.times, sig_half) elif srctype == "CircularLoop": bz_ana = mu_0 * analytics.hzAnalyticDipoleT(13, rx.times, sig_half) bz_calc = prb.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(" |bz_ana| = {ana} |bz_num| = {num} |bz_ana-bz_num| = {diff}".format( ana=np.linalg.norm(bz_ana), num=np.linalg.norm(bz_calc), diff=np.linalg.norm(bz_ana - bz_calc), )) print("Difference: {}".format(log10diff)) if plotIt is 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 run_simulation(fname="tdem_gs_half.h5", sigma_block=0.01, sigma_halfspace=0.01): from SimPEG.electromagnetics import time_domain as tdem from SimPEG.electromagnetics.utils import waveform_utils from scipy.constants import mu_0 import numpy as np from SimPEG import maps, utils from pymatsolver import Pardiso cs = 20 ncx, ncy, ncz = 20, 20, 20 npad = 10 hx = [(cs, npad, -1.5), (cs, ncx), (cs, npad, 1.5)] hy = [(cs, npad, -1.5), (cs, ncy), (cs, npad, 1.5)] hz = [(cs, npad, -1.5), (cs, ncz), (cs, npad, 1.5)] mesh = TensorMesh([hx, hy, hz], "CCC") sigma = np.ones(mesh.nC) * sigma_halfspace blk_ind = utils.ModelBuilder.getIndicesBlock(np.r_[-40, -40, -160], np.r_[40, 40, -80], mesh.gridCC) sigma[mesh.gridCC[:, 2] > 0.0] = 1e-8 sigma[blk_ind] = sigma_block xmin, xmax = -200.0, 200.0 ymin, ymax = -200.0, 200.0 x = mesh.vectorCCx[np.logical_and(mesh.vectorCCx > xmin, mesh.vectorCCx < xmax)] y = mesh.vectorCCy[np.logical_and(mesh.vectorCCy > ymin, mesh.vectorCCy < ymax)] xyz = utils.ndgrid(x, y, np.r_[-1.0]) px = np.r_[-200.0, 200.0] py = np.r_[0.0, 0.0] pz = np.r_[0.0, 0.0] srcLoc = np.c_[px, py, pz] from scipy.interpolate import interp1d t0 = 0.01 + 1e-4 times = np.logspace(-4, -2, 21) rx_ex = tdem.receivers.PointElectricField(xyz, times + t0, orientation="x") rx_ey = tdem.receivers.PointElectricField(xyz, times + t0, orientation="y") rx_by = tdem.receivers.PointElectricField(xyz, times + t0, orientation="y") rxList = [rx_ex, rx_ey, rx_by] sim = tdem.Simulation3DMagneticFluxDensity(mesh, sigma=sigma, verbose=True) sim.Solver = Pardiso sim.solverOpts = {"is_symmetric": False} sim.time_steps = [(1e-3, 10), (2e-5, 10), (1e-4, 10), (5e-4, 10), (1e-3, 10)] t0 = 0.01 + 1e-4 out = waveform_utils.VTEMFun(sim.times, 0.01, t0, 200) wavefun = interp1d(sim.times, out) waveform = tdem.sources.RawWaveform(offTime=t0, waveFct=wavefun) src = tdem.sources.LineCurrent(rxList, loc=srcLoc, waveform=waveform) survey = tdem.survey.Survey([src]) sim.survey = survey input_currents = wavefun(sim.times) f = sim.fields(sigma) xyzlim = np.array([[xmin, xmax], [ymin, ymax], [-400, 0.0]]) actinds, meshCore = utils.ExtractCoreMesh(xyzlim, mesh) Pex = mesh.getInterpolationMat(meshCore.gridCC, locType="Ex") Pey = mesh.getInterpolationMat(meshCore.gridCC, locType="Ey") Pez = mesh.getInterpolationMat(meshCore.gridCC, locType="Ez") Pfx = mesh.getInterpolationMat(meshCore.gridCC, locType="Fx") Pfy = mesh.getInterpolationMat(meshCore.gridCC, locType="Fy") Pfz = mesh.getInterpolationMat(meshCore.gridCC, locType="Fz") sigma_core = sigma[actinds] def getEBJcore(src0): B0 = np.r_[Pfx * f[src0, "b"], Pfy * f[src0, "b"], Pfz * f[src0, "b"]] E0 = np.r_[Pex * f[src0, "e"], Pey * f[src0, "e"], Pez * f[src0, "e"]] J0 = utils.sdiag(np.r_[sigma_core, sigma_core, sigma_core]) * E0 return E0, B0, J0 E, B, J = getEBJcore(src) tdem_gs = { "E": E, "B": B, "J": J, "sigma": sigma_core, "mesh": meshCore.serialize(), "time": sim.times - t0, "input_currents": input_currents, } dd.io.save(fname, tdem_gs)
src_list_ramp_on = [src_ramp_on] ############################################################################### # Create the simulations # ---------------------- # # To simulate magnetic flux data, we use the b-formulation of Maxwell's # equations survey_magnetostatic = TDEM.Survey(source_list=src_list_magnetostatic) survey_ramp_on = TDEM.Survey(src_list_ramp_on) prob_magnetostatic = TDEM.Simulation3DMagneticFluxDensity( mesh=mesh, survey=survey_magnetostatic, sigmaMap=maps.IdentityMap(mesh), time_steps=ramp, solver=Solver, ) prob_ramp_on = TDEM.Simulation3DMagneticFluxDensity( mesh=mesh, survey=survey_ramp_on, sigmaMap=maps.IdentityMap(mesh), time_steps=ramp, solver=Solver, ) ############################################################################### # Run the long on-time simulation # -------------------------------
def run_simulation(fname="tdem_vmd.h5", sigma_halfspace=0.01, src_type="VMD"): from SimPEG.electromagnetics import time_domain from scipy.constants import mu_0 import numpy as np from SimPEG import maps from pymatsolver import Pardiso cs = 20.0 ncx, ncy, ncz = 5, 3, 4 npad = 10 npadz = 10 pad_rate = 1.3 hx = [(cs, npad, -pad_rate), (cs, ncx), (cs, npad, pad_rate)] hy = [(cs, npad, -pad_rate), (cs, ncy), (cs, npad, pad_rate)] hz = utils.meshTensor([(cs, npadz, -1.3), (cs / 2.0, ncz), (cs, 5, 2)]) mesh = TensorMesh([hx, hy, hz], x0=["C", "C", -hz[:int(npadz + ncz / 2)].sum()]) sigma = np.ones(mesh.nC) * sigma_halfspace sigma[mesh.gridCC[:, 2] > 0.0] = 1e-8 xmin, xmax = -600.0, 600.0 ymin, ymax = -600.0, 600.0 zmin, zmax = -600, 100.0 times = np.logspace(-5, -2, 21) rxList = time_domain.receivers.PointMagneticFluxTimeDerivative( np.r_[10.0, 0.0, 30.0], times, orientation="z") if src_type == "VMD": src = time_domain.sources.CircularLoop( [rxList], loc=np.r_[0.0, 0.0, 30.0], orientation="Z", waveform=time_domain.sources.StepOffWaveform(), radius=13.0, ) elif src_type == "HMD": src = time_domain.sources.MagDipole( [rxList], loc=np.r_[0.0, 0.0, 30.0], orientation="X", waveform=time_domain.sources.StepOffWaveform(), ) SrcList = [src] survey = time_domain.Survey(SrcList) sig = 1e-2 sigma = np.ones(mesh.nC) * sig sigma[mesh.gridCC[:, 2] > 0] = 1e-8 prb = time_domain.Simulation3DMagneticFluxDensity( mesh, sigmaMap=maps.IdentityMap(mesh), verbose=True, survey=survey, solver=Pardiso, ) prb.time_steps = [ (1e-06, 5), (5e-06, 5), (1e-05, 10), (5e-05, 10), (1e-4, 15), (5e-4, 16), ] f = prb.fields(sigma) xyzlim = np.array([[xmin, xmax], [ymin, ymax], [zmin, zmax]]) actinds, meshCore = utils.ExtractCoreMesh(xyzlim, mesh) Pex = mesh.getInterpolationMat(meshCore.gridCC, locType="Ex") Pey = mesh.getInterpolationMat(meshCore.gridCC, locType="Ey") Pez = mesh.getInterpolationMat(meshCore.gridCC, locType="Ez") Pfx = mesh.getInterpolationMat(meshCore.gridCC, locType="Fx") Pfy = mesh.getInterpolationMat(meshCore.gridCC, locType="Fy") Pfz = mesh.getInterpolationMat(meshCore.gridCC, locType="Fz") sigma_core = sigma[actinds] def getEBJcore(src0): B0 = np.r_[Pfx * f[src0, "b"], Pfy * f[src0, "b"], Pfz * f[src0, "b"]] E0 = np.r_[Pex * f[src0, "e"], Pey * f[src0, "e"], Pez * f[src0, "e"]] J0 = utils.sdiag(np.r_[sigma_core, sigma_core, sigma_core]) * E0 return E0, B0, J0 E, B, J = getEBJcore(src) tdem_is = { "E": E, "B": B, "J": J, "sigma": sigma_core, "mesh": meshCore.serialize(), "time": prb.times, } dd.io.save(fname, tdem_is)