Parametric 1D Inversion of Sounding Data#

Here we use the module SimPEG.electromangetics.static.resistivity to invert DC resistivity sounding data and recover the resistivities and layer thicknesses for a 1D layered Earth. In this tutorial, we focus on the following:

  • How to define sources and receivers from a survey file

  • How to define the survey

  • Defining a model that consists of resistivities and layer thicknesses

For this tutorial, we will invert sounding data collected over a layered Earth using a Wenner array. The end product is layered Earth model which explains the data.

Import modules#

import os
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
import tarfile

from discretize import TensorMesh

from SimPEG import (
from SimPEG.electromagnetics.static import resistivity as dc
from SimPEG.utils import plot_1d_layer_model

mpl.rcParams.update({"font.size": 16})

# sphinx_gallery_thumbnail_number = 2

Define File Names#

Here we provide the file paths to assets we need to run the inversion. The Path to the true model is also provided for comparison with the inversion results. These files are stored as a tar-file on our google cloud bucket: “

# storage bucket where we have the data
data_source = ""

# download the data
downloaded_data =, overwrite=True)

# unzip the tarfile
tar =, "r")

# path to the directory containing our data
dir_path = downloaded_data.split(".")[0] + os.path.sep

# files to work with
data_filename = dir_path + "app_res_1d_data.dobs"
overwriting /home/vsts/work/1/s/tutorials/05-dcr/dcr1d.tar.gz
   saved to: /home/vsts/work/1/s/tutorials/05-dcr/dcr1d.tar.gz
Download completed!

Load Data, Define Survey and Plot#

Here we load the observed data, define the DC survey geometry and plot the data values.

# Load data
dobs = np.loadtxt(str(data_filename))

A_electrodes = dobs[:, 0:3]
B_electrodes = dobs[:, 3:6]
M_electrodes = dobs[:, 6:9]
N_electrodes = dobs[:, 9:12]
dobs = dobs[:, -1]

# Define survey
unique_tx, k = np.unique(np.c_[A_electrodes, B_electrodes], axis=0, return_index=True)
n_sources = len(k)
k = np.sort(k)
k = np.r_[k, len(k) + 1]

source_list = []
for ii in range(0, n_sources):

    # MN electrode locations for receivers. Each is an (N, 3) numpy array
    M_locations = M_electrodes[k[ii] : k[ii + 1], :]
    N_locations = N_electrodes[k[ii] : k[ii + 1], :]
    receiver_list = [dc.receivers.Dipole(M_locations, N_locations)]

    # AB electrode locations for source. Each is a (1, 3) numpy array
    A_location = A_electrodes[k[ii], :]
    B_location = B_electrodes[k[ii], :]
    source_list.append(dc.sources.Dipole(receiver_list, A_location, B_location))

# Define survey
survey = dc.Survey(source_list)

# Plot apparent resistivities on sounding curve as a function of Wenner separation
# parameter.
electrode_separations = 0.5 * np.sqrt(
    np.sum((survey.locations_a - survey.locations_b) ** 2, axis=1)

fig = plt.figure(figsize=(11, 5))
mpl.rcParams.update({"font.size": 14})
ax1 = fig.add_axes([0.15, 0.1, 0.7, 0.85])
ax1.semilogy(electrode_separations, dobs, "b")
ax1.set_xlabel("AB/2 (m)")
ax1.set_ylabel("Apparent Resistivity ($\Omega m$)")
plot inv 1 dcr sounding parametric

Assign Uncertainties#

Inversion with SimPEG requires that we define standard deviation on our data. This represents our estimate of the noise in our data. For DC sounding data, a relative error is applied to each datum. For this tutorial, the relative error on each datum will be 2.5%.

std = 0.025 * dobs

Define Data#

Here is where we define the data that are inverted. The data are defined by the survey, the observation values and the standard deviation.

data_object = data.Data(survey, dobs=dobs, standard_deviation=std)

Defining the Starting Model and Mapping#

In this case, the model consists of parameters which define the respective resistivities and thickness for a set of horizontal layer. Here, we choose to define a model consisting of 3 layers.

# Define the resistivities and thicknesses for the starting model. The thickness
# of the bottom layer is assumed to extend downward to infinity so we don't
# need to define it.
resistivities = np.r_[1e3, 1e3, 1e3]
layer_thicknesses = np.r_[50.0, 50.0]

# Define a mesh for plotting and regularization.
mesh = TensorMesh([(np.r_[layer_thicknesses, layer_thicknesses[-1]])], "0")

# Define model. We are inverting for the layer resistivities and layer thicknesses.
# Since the bottom layer extends to infinity, it is not a model parameter for
# which we need to invert. For a 3 layer model, there is a total of 5 parameters.
# For stability, our model is the log-resistivity and log-thickness.
starting_model = np.r_[np.log(resistivities), np.log(layer_thicknesses)]

# Since the model contains two different properties for each layer, we use
# wire maps to distinguish the properties.
wire_map = maps.Wires(("rho", mesh.nC), ("t", mesh.nC - 1))
resistivity_map = maps.ExpMap(nP=mesh.nC) * wire_map.rho
layer_map = maps.ExpMap(nP=mesh.nC - 1) * wire_map.t
TensorMesh: 3 cells

                    MESH EXTENT             CELL WIDTH      FACTOR
dir    nC        min           max         min       max      max
---   ---  ---------------------------  ------------------  ------
 x      3          0.00        150.00     50.00     50.00    1.00

Define the Physics#

Here we define the physics of the problem. The data consists of apparent resistivity values. This is defined here.

simulation = dc.simulation_1d.Simulation1DLayers(

Define Inverse Problem#

The inverse problem is defined by 3 things:

  1. Data Misfit: a measure of how well our recovered model explains the field data

  2. Regularization: constraints placed on the recovered model and a priori information

  3. Optimization: the numerical approach used to solve the inverse problem

# Define the data misfit. Here the data misfit is the L2 norm of the weighted
# residual between the observed data and the data predicted for a given model.
# Within the data misfit, the residual between predicted and observed data are
# normalized by the data's standard deviation.
dmis = data_misfit.L2DataMisfit(simulation=simulation, data=data_object)

# Define the regularization on the parameters related to resistivity
mesh_rho = TensorMesh([mesh.h[0].size])
reg_rho = regularization.WeightedLeastSquares(
    mesh_rho, alpha_s=0.01, alpha_x=1, mapping=wire_map.rho

# Define the regularization on the parameters related to layer thickness
mesh_t = TensorMesh([mesh.h[0].size - 1])
reg_t = regularization.WeightedLeastSquares(
    mesh_t, alpha_s=0.01, alpha_x=1, mapping=wire_map.t

# Combine to make regularization for the inversion problem
reg = reg_rho + reg_t

# Define how the optimization problem is solved. Here we will use an inexact
# Gauss-Newton approach that employs the conjugate gradient solver.
opt = optimization.InexactGaussNewton(maxIter=50, maxIterCG=30)

# Define the inverse problem
inv_prob = inverse_problem.BaseInvProblem(dmis, reg, opt)

Define Inversion Directives#

Here we define any directives that are carried out during the inversion. This includes the cooling schedule for the trade-off parameter (beta), stopping criteria for the inversion and saving inversion results at each iteration.

# Apply and update sensitivity weighting as the model updates
update_sensitivity_weights = directives.UpdateSensitivityWeights()

# Defining a starting value for the trade-off parameter (beta) between the data
# misfit and the regularization.
starting_beta = directives.BetaEstimate_ByEig(beta0_ratio=1e1)

# Set the rate of reduction in trade-off parameter (beta) each time the
# the inverse problem is solved. And set the number of Gauss-Newton iterations
# for each trade-off paramter value.
beta_schedule = directives.BetaSchedule(coolingFactor=5.0, coolingRate=3.0)

# Options for outputting recovered models and predicted data for each beta.
save_iteration = directives.SaveOutputEveryIteration(save_txt=False)

# Setting a stopping criteria for the inversion.
target_misfit = directives.TargetMisfit(chifact=0.1)

# The directives are defined in a list
directives_list = [

Running the Inversion#

To define the inversion object, we need to define the inversion problem and the set of directives. We can then run the inversion.

# Here we combine the inverse problem and the set of directives
inv = inversion.BaseInversion(inv_prob, directiveList=directives_list)

# Run the inversion
recovered_model =
SimPEG.InvProblem will set Regularization.reference_model to m0.
SimPEG.InvProblem will set Regularization.reference_model to m0.

                        SimPEG.InvProblem is setting bfgsH0 to the inverse of the eval2Deriv.
                        ***Done using same Solver, and solver_opts as the Simulation1DLayers problem***

model has any nan: 0
============================ Inexact Gauss Newton ============================
  #     beta     phi_d     phi_m       f      |proj(x-g)-x|  LS    Comment
x0 has any nan: 0
   0  2.49e+04  7.45e+02  0.00e+00  7.45e+02    2.99e+03      0
   1  2.49e+04  3.57e+02  1.20e-04  3.60e+02    3.16e+02      0
   2  2.49e+04  3.54e+02  1.21e-04  3.57e+02    6.91e+00      0
   3  4.98e+03  3.54e+02  1.08e-04  3.55e+02    3.67e+02      4
   4  4.98e+03  3.45e+02  9.77e-04  3.50e+02    8.98e+01      0
   5  4.98e+03  3.44e+02  8.44e-04  3.48e+02    2.48e+02      2   Skip BFGS
   6  9.96e+02  3.44e+02  9.74e-04  3.45e+02    2.72e+02      3
   7  9.96e+02  3.42e+02  1.23e-03  3.43e+02    2.88e+02      3
   8  9.96e+02  3.39e+02  2.73e-03  3.42e+02    2.41e+02      2
   9  1.99e+02  3.37e+02  2.79e-03  3.37e+02    2.42e+02      3
  10  1.99e+02  3.17e+02  2.11e-02  3.21e+02    5.34e+02      2
  11  1.99e+02  2.82e+02  1.02e-01  3.02e+02    6.93e+02      2
  12  3.98e+01  2.28e+02  1.83e-01  2.36e+02    4.59e+02      1
  13  3.98e+01  2.14e+02  4.29e-01  2.31e+02    8.14e+02      2
  14  3.98e+01  1.09e+02  9.77e-01  1.48e+02    3.49e+02      1
  15  7.97e+00  8.83e+01  1.19e+00  9.78e+01    4.22e+02      1
  16  7.97e+00  4.99e+01  3.11e+00  7.46e+01    8.69e+02      0
  17  7.97e+00  1.18e+01  3.87e+00  4.26e+01    1.74e+02      0
  18  1.59e+00  1.25e+01  3.23e+00  1.76e+01    1.57e+02      1
  19  1.59e+00  8.16e+00  4.19e+00  1.48e+01    2.34e+02      1
  20  1.59e+00  2.66e+00  5.54e+00  1.15e+01    6.32e+01      0   Skip BFGS
  21  3.19e-01  2.66e+00  5.44e+00  4.40e+00    8.16e+00      0
  22  3.19e-01  2.12e+00  5.93e+00  4.01e+00    1.32e+02      1
------------------------- STOP! -------------------------
1 : |fc-fOld| = 0.0000e+00 <= tolF*(1+|f0|) = 7.4614e+01
1 : |xc-x_last| = 2.1393e-01 <= tolX*(1+|x0|) = 1.4182e+00
0 : |proj(x-g)-x|    = 1.3215e+02 <= tolG          = 1.0000e-01
0 : |proj(x-g)-x|    = 1.3215e+02 <= 1e3*eps       = 1.0000e-02
0 : maxIter   =      50    <= iter          =     23
------------------------- DONE! -------------------------

Examining the Results#

# Define true model and layer thicknesses
true_model = np.r_[1e3, 4e3, 2e2]
true_layers = np.r_[100.0, 100.0]

# Plot true model and recovered model
fig = plt.figure(figsize=(5, 5))

x_min = np.min([np.min(resistivity_map * recovered_model), np.min(true_model)])
x_max = np.max([np.max(resistivity_map * recovered_model), np.max(true_model)])

ax1 = fig.add_axes([0.2, 0.15, 0.7, 0.7])
plot_1d_layer_model(true_layers, true_model, ax=ax1, plot_elevation=True, color="b")
    layer_map * recovered_model,
    resistivity_map * recovered_model,
ax1.set_xlabel(r"Resistivity ($\Omega m$)")
ax1.set_xlim(0.9 * x_min, 1.1 * x_max)
ax1.legend(["True Model", "Recovered Model"])

# Plot the true and apparent resistivities on a sounding curve
fig = plt.figure(figsize=(11, 5))
ax1 = fig.add_axes([0.2, 0.05, 0.6, 0.8])
ax1.semilogy(electrode_separations, dobs, "b")
ax1.semilogy(electrode_separations, inv_prob.dpred, "r")
ax1.set_xlabel("AB/2 (m)")
ax1.set_ylabel(r"Apparent Resistivity ($\Omega m$)")
ax1.legend(["True Sounding Curve", "Predicted Sounding Curve"])
  • plot inv 1 dcr sounding parametric
  • plot inv 1 dcr sounding parametric

Total running time of the script: ( 0 minutes 22.871 seconds)

Estimated memory usage: 18 MB

Gallery generated by Sphinx-Gallery