In this notebook, we will simulate an FDEM sounding over a conductive sphere. A cylindrical mesh and the SimPEG Electromanetics module is used to perform the simulation.

For more on SimPEG and SimPEG.EM see:

- (Cockett et al., 2015):
*SimPEG: An open source framework for simulation and gradient based parameter estimation in geophysical applications* - (Heagy et al., 2016):
*A framework for simulation and inversion in electromagnetics*

An inductive loop transmitter is centered over an electrically conductive sphere (radius 30m). The transmitter is 20m above the surface, and the center of the sphere is 50m below the surface. A coil receiver is offset by 8m horizontally from the transmitter.

NumPy, SciPy and Matplotlib are core Python packages that can be installed when you install python with a distribution such as Anaconda.

SimPEG is a Simulation and Inversion package for geophysics.

If you would like to set up and run SimPEG on your machine, see http://simpeg.xyz and http://tutorials.simpeg.xyz

In [1]:

```
# Basic python packages
import numpy as np
import matplotlib.pyplot as plt
from scipy.constants import mu_0
# Modules of SimPEG we will use for forward modelling
from SimPEG import Mesh, Utils, Maps
from SimPEG.EM import FDEM
from SimPEG import SolverLU as Solver
# Set a nice colormap!
plt.set_cmap(plt.get_cmap('viridis'))
%matplotlib inline
```

We define a

- resistive halfspace and
- conductive sphere
- radius of 30m
- center is 50m below the surface

In [2]:

```
# electrical conductivities in S/m
sig_halfspace = 1e-6
sig_sphere = 1e-2
sig_air = 1e-8
```

In [3]:

```
# depth to center, radius in m
sphere_z = -50.
sphere_radius = 30.
```

- Transmitter and receiver 20m above the surface
- Receiver offset from transmitter by 8m horizontally
- 25 frequencies, logaritmically between $10^3$ Hz and $10^6$ Hz

In [4]:

```
boom_height = 20.
rx_offset = 8.
freqs = np.logspace(3, 6, 25)
# source and receiver location in 3D space
src_loc = np.r_[0., 0., boom_height]
rx_loc = np.atleast_2d(np.r_[rx_offset, 0., boom_height])
```

In [5]:

```
# print the min and max skin depths to make sure mesh is fine enough and
# extends far enough
def skin_depth(sigma, f):
return 500./np.sqrt(sigma * f)
print(
'Minimum skin depth (in sphere): {:.2e} m '.format(skin_depth(sig_sphere, freqs.max()))
)
print(
'Maximum skin depth (in background): {:.2e} m '.format(skin_depth(sig_halfspace, freqs.min()))
)
```

Here, we define a cylindrically symmetric tensor mesh.

The figure below shows a cell in a cartesian mesh (a) and a cylindrically symmetric mesh (b). Note that edges are rotational and faces are radial and vertical in the cylindrically symmetric mesh.

For the mesh, we will use a cylindrically symmetric tensor mesh. To construct a tensor mesh, all that is needed is a vector of cell widths in the x and z-directions. We will define a core mesh region of uniform cell widths and a padding region where the cell widths expand "to infinity".

In [6]:

```
# x-direction
csx = 2 # core mesh cell width in the x-direction
ncx = np.ceil(1.2*sphere_radius/csx) # number of core x-cells (uniform mesh slightly beyond sphere radius)
npadx = 30 # number of x padding cells
# z-direction
csz = 1 # core mesh cell width in the z-direction
ncz = np.ceil(1.2*(boom_height - (sphere_z-sphere_radius))/csz) # number of core z-cells (uniform cells slightly below bottom of sphere)
npadz = 32 # number of z padding cells
# padding factor (expand cells to infinity)
pf = 1.3
```

In [7]:

```
# cell spacings in the x and z directions
hx = Utils.meshTensor([(csx, ncx), (csx, npadx, pf)])
hz = Utils.meshTensor([(csz, npadz, -pf), (csz, ncz), (csz, npadz, pf)])
# define a SimPEG mesh
mesh = Mesh.CylMesh([hx, 1, hz], x0 = np.r_[0.,0., -hz.sum()/2.-boom_height])
```

Below, we plot the mesh. The cyl mesh is rotated around x=0. Ensure that each dimension extends beyond the maximum skin depth.

Zoom in by changing the xlim and zlim.

In [8]:

```
# X and Z limits we want to plot to. Try changing them to see the core region of the mesh
xlim = np.r_[0., 2.5e4]
zlim = np.r_[-2.5e4, 2.5e4]
fig, ax = plt.subplots(1,1)
mesh.plotGrid(ax=ax)
ax.set_title('Simulation Mesh')
ax.set_xlim(xlim)
ax.set_ylim(zlim)
print(
'The maximum skin depth (in background) is: {:.2e} m. '
'Does the mesh go sufficiently past that?'.format(
skin_depth(sig_halfspace, freqs.min())
)
)
```

Now that the model parameters and mesh are defined, we can define electrical conductivity on the mesh.

The electrical conductivity is defined at cell centers when using the finite volume method. So here, we define a vector that contains an electrical conductivity value for every cell center.

In [9]:

```
# create a vector that has one entry for every cell center
sigma = sig_air*np.ones(mesh.nC) # start by defining the conductivity of the air everwhere
sigma[mesh.gridCC[:,2] < 0.] = sig_halfspace # assign halfspace cells below the earth
# indices of the sphere (where (x-x0)**2 + (z-z0)**2 <= R**2)
sphere_ind = (mesh.gridCC[:,0]**2 + (mesh.gridCC[:,2] - sphere_z)**2) <= sphere_radius**2
sigma[sphere_ind] = sig_sphere # assign the conductivity of the sphere
```

In [10]:

```
# Plot a cross section of the conductivity model
fig, ax = plt.subplots(1,1)
cb = plt.colorbar(mesh.plotImage(np.log10(sigma), ax=ax, mirror=True)[0])
# plot formatting and titles
cb.set_label('$\log_{10}\sigma$', fontsize=13)
ax.axis('equal')
ax.set_xlim([-120., 120.])
ax.set_ylim([-100., 30.])
ax.set_title('Conductivity Model')
```

Out[10]:

Here, we define sources and receivers. For this example, the receivers are magnetic flux recievers, and are only looking at the secondary field (eg. if a bucking coil were used to cancel the primary). The source is a vertical magnetic dipole with unit moment.

In [11]:

```
# Define the receivers, we will sample the real secondary magnetic flux density
# as well as the imaginary magnetic flux density
bz_r = FDEM.Rx.Point_bSecondary(locs=rx_loc, orientation='z', component='real') # vertical real b-secondary
bz_i = FDEM.Rx.Point_b(locs=rx_loc, orientation='z', component='imag') # vertical imag b (same as b-secondary)
rxList = [bz_r, bz_i] # list of receivers
```

In [12]:

```
# Define the list of sources - one source for each frequency.
# The source is a point dipole oriented in the z-direction
srcList = [FDEM.Src.MagDipole(rxList, f, src_loc, orientation='z') for f in freqs]
print(
'There are {nsrc} sources (same as the number of frequencies - {nfreq}). '
'Each source has {nrx} receivers sampling the resulting b-fields'.format(
nsrc = len(srcList),
nfreq = len(freqs),
nrx = len(rxList)
)
)
```

A forward simulation consists of a paired SimPEG problem and Survey. For this example, we use the E-formulation of Maxwell's equations, solving the second-order system for the electric field, which is defined on the cell edges of the mesh. This is the `prob`

variable below. The `survey`

takes the source list which is used to construct the RHS for the problem. The source list also contains the receiver information, so the `survey`

knows how to sample fields and fluxes that are produced by solving the `prob`

.

**An Aside: Mappings**

The `sigmaMap`

defines a mapping which translates an input vector to a physical property - specifically, $\sigma$. This comes in handy when you want to invert for $\log(\sigma)$, in that case, the model is defined in terms of log-conductivity, and you would need an `ExpMap`

to translate $\log(\sigma) \to \sigma$

In [13]:

```
# define a problem - the statement of which discrete pde system we want to solve
prob = FDEM.Problem3D_e(mesh, sigmaMap=Maps.IdentityMap(mesh))
prob.solver = Solver
survey = FDEM.Survey(srcList)
# tell the problem and survey about each other - so the RHS can be constructed
# for the problem and the resulting fields and fluxes can be sampled by the receiver.
prob.pair(survey)
```

Here, we solve the problem for the fields everywhere on the mesh.

In [14]:

```
%%time
print('solving {nfreq} FDEM forward problems...'.format(nfreq=len(freqs)))
fields = prob.fields(sigma)
print('... done')
```

Lets look at the physics!

In [15]:

```
# log-scale the colorbar
from matplotlib.colors import LogNorm
import ipywidgets
```

In [16]:

```
def plot_bSecondary(
freq_ind=0, # which frequency would you like to look at?
reim='real' # real or imaginary part
# ax=ax
):
fig, ax = plt.subplots(1,1, figsize=(6,5))
# Plot the magnetic flux
field_to_plot = getattr(fields[srcList[freq_ind], 'bSecondary'], reim)
max_field = np.abs(field_to_plot).max() #use to set colorbar limits
cb_range = 5e2 # dynamic range of colorbar
cb = plt.colorbar(mesh.plotImage(
field_to_plot,
vType='F', view='vec',
range_x=[-120., 120.], range_y=[-180., 80.],
pcolorOpts={
'norm': LogNorm(),
'cmap': plt.get_cmap('viridis')
},
streamOpts={'color': 'w'}, mirror=True, ax=ax,
clim=[max_field/cb_range, max_field]
)[0], ax=ax)
ax.set_xlim([-120., 120.])
ax.set_ylim([-180., 70.])
cb.set_label('|B {reim}|'.format(reim=reim))
# plot the outline of the sphere
x = np.linspace(-sphere_radius, sphere_radius, 100)
ax.plot(x, np.sqrt(sphere_radius**2 - x**2) + sphere_z, color='k')
ax.plot(x, -np.sqrt(sphere_radius**2 - x**2) + sphere_z, color='k')
# plot the source and receiver locations
ax.plot(src_loc[0],src_loc[2],'co', markersize=6)
ax.plot(rx_loc[0,0],rx_loc[0,2],'mo', markersize=6)
# plot the surface of the earth
ax.plot(np.r_[-200, 200], np.r_[0., 0.], 'w:')
# give it a title
ax.set_title(
'B {reim}, {freq:10.2f} Hz'.format(
reim=reim,
freq=freqs[freq_ind]
)
)
plt.show()
return ax
ipywidgets.interact(
plot_bSecondary,
freq_ind=ipywidgets.IntSlider(min=0, max=len(freqs)-1, value=0),
reim=ipywidgets.ToggleButtons(options=['real', 'imag'])
)
```

Out[16]:

If simulating a DIGHEM survey, for example, the data are provided as the ratio of the secondary field with the primary as measured at the receiver in free space.

In what follows, we set calculate the primary field at the receiver, calcuate the secondary magnetic fields measured by the receiver (**dpred**) and then take the ratio with the primary.

In [17]:

```
# Primary Field at receiver
rx = rxList[0]
P = rx.getP(mesh, 'Fz')
bprimary = fields[srcList[1], 'bPrimary']
b0 = P*bprimary
b0 = b0[0][0].real
```

In [18]:

```
dpred = survey.dpred(sigma, f=fields)
```

In [19]:

```
# reshape the data vector by sources and receivers
dpred_reshaped = dpred.reshape((len(rxList), len(srcList)), order='F').T
dpred_real = dpred_reshaped[:,0]
dpred_imag = dpred_reshaped[:,1]
```

In [20]:

```
# Plot
fig, ax = plt.subplots(1,1)
ax.semilogx(freqs, dpred_real/b0*1e6)
ax.semilogx(freqs, dpred_imag/b0*1e6)
ax.grid(True, color='k',linestyle="-", linewidth=0.1)
ax.legend(['real','imag'], loc='best')
# ax.set_title('Sounding over Sphere')
ax.set_ylabel('magnetic field (ppm of primary)')
ax.set_xlabel('frequency (Hz)')
```

Out[20]:

In [ ]:

```
```