Azure CI deploy v0.25.0 from 5f060ec0a

Author: simpeg-bot

latest

@@ -1 +1 @@
-v0.24.0
+v0.25.0

v0.25.0/.buildinfo

@@ -0,0 +1,4 @@
+# Sphinx build info version 1
+# This file records the configuration used when building these files. When it is not found, a full rebuild will be done.
+config: b875a16033d1afb3fc33f43f228f2caa
+tags: 645f666f9bcd5a90fca523b33c5a78b7

v0.25.0/_downloads/004cedfd73e46c626a3057b55c06fc55/plot_fwd_1_em1dtm.py

@@ -0,0 +1,174 @@
+"""
+1D Forward Simulation for a Single Sounding
+===========================================
+
+Here we use the module *simpeg.electromangetics.time_domain_1d* to predict
+the stepoff response for a single sounding over a 1D layered Earth.
+In this tutorial, we focus on the following:
+
+    - Defining receivers, waveforms, sources and the survey
+    - The units of the model and resulting data
+    - Defining and running the 1D simulation for a single sounding
+
+Our survey geometry consists of a horizontal loop source with a radius of 6 m
+located 20 m above the Earth's surface. The receiver is located at the centre
+of the loop and measures the vertical component of the response.
+
+
+"""
+
+#####################################################
+# Import Modules
+# --------------
+#
+
+import numpy as np
+import os
+from matplotlib import pyplot as plt
+
+from simpeg import maps
+import simpeg.electromagnetics.time_domain as tdem
+from simpeg.utils import plot_1d_layer_model
+
+write_output = False
+plt.rcParams.update({"font.size": 16})
+
+# sphinx_gallery_thumbnail_number = 2
+
+#####################################################################
+# Create Survey
+# -------------
+#
+# Here we demonstrate a general way to define the receivers, sources, waveforms and survey.
+# For this tutorial, the source is a horizontal loop whose current waveform
+# is a unit step-off. The receiver measures the vertical component of the magnetic flux
+# density at the loop's center.
+#
+
+# Source properties
+source_location = np.array([0.0, 0.0, 20.0])
+source_orientation = "z"  # "x", "y" or "z"
+source_current = 1.0  # maximum on-time current
+source_radius = 6.0  # source loop radius
+
+# Receiver properties
+receiver_location = np.array([0.0, 0.0, 20.0])
+receiver_orientation = "z"  # "x", "y" or "z"
+times = np.logspace(-5, -2, 31)  # time channels (s)
+
+# Define receiver list. In our case, we have only a single receiver for each source.
+# When simulating the response for multiple component and/or field orientations,
+# the list consists of multiple receiver objects.
+receiver_list = []
+receiver_list.append(
+    tdem.receivers.PointMagneticFluxDensity(
+        receiver_location, times, orientation=receiver_orientation
+    )
+)
+
+# Define the source waveform. Here we define a unit step-off. The definition of
+# other waveform types is covered in a separate tutorial.
+waveform = tdem.sources.StepOffWaveform()
+
+# Define source list. In our case, we have only a single source.
+source_list = [
+    tdem.sources.CircularLoop(
+        receiver_list=receiver_list,
+        location=source_location,
+        waveform=waveform,
+        current=source_current,
+        radius=source_radius,
+    )
+]
+
+# Define the survey
+survey = tdem.Survey(source_list)
+
+
+###############################################
+# Defining a 1D Layered Earth Model
+# ---------------------------------
+#
+# Here, we define the layer thicknesses and electrical conductivities for our
+# 1D simulation. If we have N layers, we define N electrical conductivity
+# values and N-1 layer thicknesses. The lowest layer is assumed to extend to
+# infinity. If the Earth is a halfspace, the thicknesses can be defined by
+# an empty array, and the physical property values by an array of length 1.
+#
+# In this case, we have a more conductive layer within a background halfspace.
+# This can be defined as a 3 layered Earth model.
+#
+
+# Physical properties
+background_conductivity = 1e-1
+layer_conductivity = 1e0
+
+# Layer thicknesses
+thicknesses = np.array([40.0, 40.0])
+n_layer = len(thicknesses) + 1
+
+# physical property models
+model = background_conductivity * np.ones(n_layer)
+model[1] = layer_conductivity
+
+# Define a mapping for conductivities
+model_mapping = maps.IdentityMap(nP=n_layer)
+
+# Plot conductivity model
+thicknesses_for_plotting = np.r_[thicknesses, 40.0]
+
+fig = plt.figure(figsize=(6, 5))
+ax = fig.add_axes([0.15, 0.15, 0.8, 0.8])
+plot_1d_layer_model(thicknesses_for_plotting, model, ax=ax, show_layers=False)
+plt.gca().invert_yaxis()
+
+
+#######################################################################
+# Define the Forward Simulation, Predict Data and Plot
+# ----------------------------------------------------
+#
+# Here we define the simulation and predict the 1D TDEM sounding data.
+# The simulation requires the user define the survey, the layer thicknesses
+# and a mapping from the model to the conductivities of the layers.
+#
+# When using the *simpeg.electromagnetics.time_domain_1d* module,
+# predicted data are organized by source, then by receiver, then by time channel.
+#
+
+# Define the simulation
+simulation = tdem.Simulation1DLayered(
+    survey=survey,
+    thicknesses=thicknesses,
+    sigmaMap=model_mapping,
+)
+
+# Predict data for a given model
+dpred = simulation.dpred(model)
+
+# Plot sounding
+fig = plt.figure(figsize=(6, 6))
+ax = fig.add_axes([0.2, 0.15, 0.75, 0.78])
+ax.loglog(times, dpred, "k-o", lw=2)
+ax.set_xlabel("Times (s)")
+ax.set_ylabel("|B| (T)")
+ax.set_title("Magnetic Flux")
+
+
+##################################################
+# Write Output (Optional)
+# -----------------------
+#
+
+if write_output:
+    dir_path = os.path.dirname(__file__).split(os.path.sep)
+    dir_path.extend(["outputs"])
+    dir_path = os.path.sep.join(dir_path) + os.path.sep
+
+    if not os.path.exists(dir_path):
+        os.mkdir(dir_path)
+
+    np.random.seed(347)
+    noise = 0.05 * np.abs(dpred) * np.random.randn(len(dpred))
+    dpred += noise
+    fname = dir_path + "em1dtm_data.txt"
+    np.savetxt(fname, np.c_[times, dpred], fmt="%.4e", header="TIME BZ")

v0.25.0/_downloads/019439707d935e00dfed075169ee3154/plot_fwd_2_vrm_topsoil.ipynb

@@ -0,0 +1,158 @@
+{
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "\n# Forward Simulation of VRM Response on a Tree Mesh\n\nHere we use the module *simpeg.electromagnetics.viscous_remanent_magnetization*\nto predict the characteristic VRM response over magnetically viscous top soil.\nWe consider a small-loop, ground-based survey which uses a coincident loop\ngeometry. For this tutorial, we focus on the following:\n\n    - How to define the transmitters and receivers\n    - How to define the survey\n    - How to define a diagnostic physical property\n    - How to define the physics for the linear potential fields formulation\n    - How to include surface topography (if desired)\n    - Modeling on an OcTree mesh\n\n\nNote that for this tutorial, we are only modeling the VRM response. A separate\ntutorial have been developed for modeling both the inductive and VRM responses.\n"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Import modules\n\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from simpeg.electromagnetics import viscous_remanent_magnetization as vrm\nfrom simpeg.utils import plot2Ddata\nfrom simpeg import maps\n\nfrom discretize import TreeMesh\nfrom discretize.utils import mkvc, refine_tree_xyz, active_from_xyz\n\nimport numpy as np\nfrom scipy.interpolate import LinearNDInterpolator\n\nimport matplotlib.pyplot as plt\nimport matplotlib as mpl\n\n# sphinx_gallery_thumbnail_number = 2"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Defining Topography\n\nSurface topography is defined as an (N, 3) numpy array. We create it here but\nthe topography could also be loaded from a file. To keep the example simple,\nwe set flat topography at z = 0 m.\n\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "[x_topo, y_topo, z_topo] = np.meshgrid(\n    np.linspace(-100, 100, 41), np.linspace(-100, 100, 41), 0.0\n)\nx_topo, y_topo, z_topo = mkvc(x_topo), mkvc(y_topo), mkvc(z_topo)\nxyz_topo = np.c_[x_topo, y_topo, z_topo]"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Survey\n\nHere we define the sources, the receivers and the survey. For this exercise,\na coincident loop-loop system measures the vertical component of the VRM\nresponse.\n\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "# Define the transmitter waveform. This strongly determines the behaviour of the\n# characteristic VRM response. Here we use a step-off. The off-time begins at\n# 0 s.\nwaveform = vrm.waveforms.StepOff(t0=0)\n\n# Define the time channels for the receivers. The time channels must ALL be\n# ALL the off-time defined by the waveform.\ntime_channels = np.logspace(-4, -1, 31)\n\n# Define the transmitter and receiver locations. This step will define the\n# receivers 0.5 m above the Earth in the even you use more general topography.\nx = np.linspace(-40.0, 40.0, 21)\ny = np.linspace(-40.0, 40.0, 21)\nx, y = np.meshgrid(x, y)\nx, y = mkvc(x.T), mkvc(y.T)\nfun_interp = LinearNDInterpolator(np.c_[x_topo, y_topo], z_topo)\nz = fun_interp(np.c_[x, y]) + 0.5  # sensor height 0.5 m above surface.\nlocations = np.c_[mkvc(x), y, z]\n\n# Define the source-receiver pairs\nsource_list = []\nfor pp in range(0, locations.shape[0]):\n    # Define dbz/dt receiver\n    loc_pp = np.reshape(locations[pp, :], (1, 3))\n    receivers_list = [\n        vrm.receivers.Point(\n            loc_pp, times=time_channels, field_type=\"dbdt\", orientation=\"z\"\n        )\n    ]\n\n    dipole_moment = [0.0, 0.0, 1.0]\n\n    # Define the source\n    source_list.append(\n        vrm.sources.MagDipole(\n            receivers_list, mkvc(locations[pp, :]), dipole_moment, waveform\n        )\n    )\n\n# Define the survey\nsurvey = vrm.Survey(source_list)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Defining an OcTree Mesh\n\nHere, we create the OcTree mesh that will be used for the tutorial. Since only\nthe very near surface contributes significantly to the response, the dimensions\nof the domain in the z-direction can be small. Here, we are assuming the\nmagnetic viscosity is negligible below 8 metres.\n\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "dx = 2  # minimum cell width (base mesh cell width) in x\ndy = 2  # minimum cell width (base mesh cell width) in y\ndz = 1  # minimum cell width (base mesh cell width) in z\n\nx_length = 100.0  # domain width in x\ny_length = 100.0  # domain width in y\nz_length = 8.0  # domain width in y\n\n# Compute number of base mesh cells required in x and y\nnbcx = 2 ** int(np.round(np.log(x_length / dx) / np.log(2.0)))\nnbcy = 2 ** int(np.round(np.log(y_length / dy) / np.log(2.0)))\nnbcz = 2 ** int(np.round(np.log(z_length / dz) / np.log(2.0)))\n\n# Define the base mesh\nhx = [(dx, nbcx)]\nhy = [(dy, nbcy)]\nhz = [(dz, nbcz)]\nmesh = TreeMesh([hx, hy, hz], x0=\"CCN\")\n\n# Refine based on surface topography\nmesh = refine_tree_xyz(\n    mesh, xyz_topo, octree_levels=[2, 2], method=\"surface\", finalize=False\n)\n\nmesh.finalize()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Defining the Model\n\nFor the linear potential field formulation, the magnetic viscosity\ncharacterizing each cell can be defined by an \"amalgamated magnetic property\"\n(see Cowan, 2016). Here we define an amalgamated magnetic property model.\nThe model is made by summing a set of 3D Gaussian distributions.\n\nFor other formulations of the forward simulation, you may define the parameters\nassuming a log-uniform or log-normal distribution of time-relaxation constants.\n\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "# Find cells active in the forward simulation (cells below surface)\nind_active = active_from_xyz(mesh, xyz_topo)\n\n# Define 3D Gaussian distribution parameters\nxyzc = mesh.gridCC[ind_active, :]\nc = 3 * np.pi * 8**2\npc = np.r_[4e-4, 4e-4, 4e-4, 6e-4, 8e-4, 6e-4, 8e-4, 8e-4]\nx_0 = np.r_[50.0, -50.0, -40.0, -20.0, -15.0, 20.0, -10.0, 25.0]\ny_0 = np.r_[0.0, 0.0, 40.0, 10.0, -20.0, 15.0, 0.0, 0.0]\nz_0 = np.r_[0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]\nvar_x = c * np.r_[3.0, 3.0, 3.0, 1.0, 3.0, 0.5, 0.1, 0.1]\nvar_y = c * np.r_[20.0, 20.0, 1.0, 1.0, 0.4, 0.5, 0.1, 0.4]\nvar_z = c * np.r_[1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]\n\n# Define model\nmodel = np.zeros(np.shape(xyzc[:, 0]))\nfor ii in range(0, 8):\n    model += (\n        pc[ii]\n        * np.exp(-((xyzc[:, 0] - x_0[ii]) ** 2) / var_x[ii])\n        * np.exp(-((xyzc[:, 1] - y_0[ii]) ** 2) / var_y[ii])\n        * np.exp(-((xyzc[:, 2] - z_0[ii]) ** 2) / var_z[ii])\n    )\n\n# Plot Model\nmpl.rcParams.update({\"font.size\": 12})\nfig = plt.figure(figsize=(7.5, 7))\n\nplotting_map = maps.InjectActiveCells(mesh, ind_active, np.nan)\nax1 = fig.add_axes([0.09, 0.12, 0.72, 0.77])\nmesh.plot_slice(\n    plotting_map * model,\n    normal=\"Z\",\n    ax=ax1,\n    ind=0,\n    grid=True,\n    clim=(np.min(model), np.max(model)),\n    pcolor_opts={\"cmap\": \"magma_r\"},\n)\nax1.set_title(\"Model slice at z = 0 m\")\nax1.set_xlabel(\"x (m)\")\nax1.set_ylabel(\"y (m)\")\n\nax2 = fig.add_axes([0.83, 0.12, 0.05, 0.77])\nnorm = mpl.colors.Normalize(vmin=np.min(model), vmax=np.max(model))\ncbar = mpl.colorbar.ColorbarBase(\n    ax2, norm=norm, orientation=\"vertical\", cmap=mpl.cm.magma_r\n)\ncbar.set_label(\"Amalgamated Magnetic Property (SI)\", rotation=270, labelpad=15, size=12)\n\nplt.show()"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Define the Simulation\n\nHere we define the formulation for solving Maxwell's equations. We have chosen\nto model the off-time VRM response. There are two important keyword arguments,\n*refinement_factor* and *refinement_distance*. These are used to refine the\nsensitivities of the cells near the transmitters. This improves the accuracy\nof the forward simulation without having to refine the mesh near transmitters.\n\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "# For this example, cells lying within 2 m of a transmitter will be modeled\n# as if they are comprised of 4^3 equal smaller cells. Cells within 4 m of a\n# transmitter will be modeled as if they are comprised of 2^3 equal smaller\n# cells.\nsimulation = vrm.Simulation3DLinear(\n    mesh,\n    survey=survey,\n    active_cells=ind_active,\n    refinement_factor=2,\n    refinement_distance=[2.0, 4.0],\n)"
+      ]
+    },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "## Predict Data and Plot\n\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "# Predict VRM response\ndpred = simulation.dpred(model)\n\n# Reshape for plotting\nn_times = len(time_channels)\nn_loc = locations.shape[0]\ndpred = np.reshape(dpred, (n_loc, n_times))\n\n# Plot\nfig = plt.figure(figsize=(13, 5))\n\n# Index for what time channel you would like to see the data map.\ntime_index = 10\n\nv_max = np.max(np.abs(dpred[:, time_index]))\nv_min = np.min(np.abs(dpred[:, time_index]))\nax11 = fig.add_axes([0.12, 0.1, 0.33, 0.85])\nplot2Ddata(\n    locations[:, 0:2],\n    -dpred[:, time_index],\n    ax=ax11,\n    ncontour=30,\n    clim=(v_min, v_max),\n    contourOpts={\"cmap\": \"magma_r\"},\n)\nax11.set_xlabel(\"x (m)\")\nax11.set_ylabel(\"y (m)\")\ntitlestr = \"- dBz/dt at t=\" + \"{:.1e}\".format(time_channels[time_index]) + \" s\"\nax11.set_title(titlestr)\n\nax12 = fig.add_axes([0.46, 0.1, 0.02, 0.85])\nnorm1 = mpl.colors.Normalize(vmin=v_min, vmax=v_max)\ncbar1 = mpl.colorbar.ColorbarBase(\n    ax12, norm=norm1, orientation=\"vertical\", cmap=mpl.cm.magma_r\n)\ncbar1.set_label(\"$T/s$\", rotation=270, labelpad=15, size=12)\n\n# Indicies for some locations you would like to see the decay\nlocation_indicies = [0, 65, 217]\ncolor_flags = [\"k\", \"r\", \"b\"]\nlegend_str = []\n\nax2 = fig.add_axes([0.6, 0.1, 0.35, 0.85])\nfor ii in range(0, len(location_indicies)):\n    ax2.loglog(time_channels, -dpred[location_indicies[ii], :], color_flags[ii], lw=2)\n    legend_str.append(\n        \"(\"\n        + \"{:.1f}\".format(locations[location_indicies[ii], 0])\n        + \" m, \"\n        + \"{:.1f}\".format(locations[location_indicies[ii], 1])\n        + \" m)\"\n    )\n\nax2.set_xlim((np.min(time_channels), np.max(time_channels)))\nax2.set_xlabel(\"time [s]\")\nax2.set_ylabel(\"-dBz/dt [T/s]\")\nax2.set_title(\"Decay Curve\")\nax2.legend(legend_str)"
+      ]
+    }
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.11.14"
+    }
+  },
+  "nbformat": 4,
+  "nbformat_minor": 0
+}