{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Implementation of a Devito self adjoint variable density visco- acoustic isotropic modeling operator
-- Linearized Ops --\n", "\n", "## This operator is contributed by Chevron Energy Technology Company (2020)\n", "\n", "This operator is based on simplfications of the systems presented in:\n", "
**Self-adjoint, energy-conserving second-order pseudoacoustic systems for VTI and TTI media for reverse time migration and full-waveform inversion** (2016)\n", "
Kenneth Bube, John Washbourne, Raymond Ergas, and Tamas Nemeth\n", "
SEG Technical Program Expanded Abstracts\n", "
https://library.seg.org/doi/10.1190/segam2016-13878451.1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Introduction \n", "\n", "The goal of this tutorial set is to generate and prove correctness of modeling and inversion capability in Devito for variable density visco- acoustics using an energy conserving form of the wave equation. We describe how the linearization of the energy conserving *self adjoint* system with respect to modeling parameters allows using the same modeling system for all nonlinear and linearized forward and adjoint finite difference evolutions. There are three notebooks in this series:\n", "\n", "##### 1. Implementation of a Devito self adjoint variable density visco- acoustic isotropic modeling operator -- Nonlinear Ops\n", "- Implement the nonlinear modeling operations. \n", "- [sa_01_iso_implementation1.ipynb](sa_01_iso_implementation1.ipynb)\n", "\n", "##### 2. Implementation of a Devito self adjoint variable density visco- acoustic isotropic modeling operator -- Linearized Ops\n", "- Implement the linearized (Jacobian) ```forward``` and ```adjoint``` modeling operations.\n", "- [sa_02_iso_implementation2.ipynb](sa_02_iso_implementation2.ipynb)\n", "\n", "##### 3. Implementation of a Devito self adjoint variable density visco- acoustic isotropic modeling operator -- Correctness Testing\n", "- Tests the correctness of the implemented operators.\n", "- [sa_03_iso_correctness.ipynb](sa_03_iso_correctness.ipynb)\n", "\n", "There are similar series of notebooks implementing and testing operators for VTI and TTI anisotropy ([README.md](README.md)).\n", "\n", "Below we continue the implementation of our *self adjoint* wave equation with dissipation only Q attenuation, and linearize the modeling operator with respect to the model parameter velocity. We show how to implement finite difference evolutions to compute the action of the ```forward``` and ```adjoint``` Jacobian. \n", "\n", "## Outline \n", "1. Define symbols \n", "2. The nonlinear operator \n", "3. The Jacobian opeator \n", "4. Create the Devito grid and model fields \n", "5. The simulation time range and acquistion geometry \n", "6. Implement and run the nonlinear forward operator \n", "7. Implement and run the Jacobian forward operator \n", "8. Implement and run the Jacobian adjoint operator \n", "9. References \n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Table of symbols\n", "\n", "There are many more symbols for the Jacobian than we had in the previous notebook. We need to introduce terminology for the nonlinear operator, including total, background and perturbation fields for several variables. \n", "\n", "| Symbol                       | Description | Dimensionality | \n", "|:---|:---|:---|\n", "| $\\overleftarrow{\\partial_t}$ | shifted first derivative wrt $t$ | shifted 1/2 sample backward in time |\n", "| $\\partial_{tt}$ | centered second derivative wrt $t$ | centered in time |\n", "| $\\overrightarrow{\\partial_x},\\ \\overrightarrow{\\partial_y},\\ \\overrightarrow{\\partial_z}$ | + shifted first derivative wrt $x,y,z$ | shifted 1/2 sample forward in space |\n", "| $\\overleftarrow{\\partial_x},\\ \\overleftarrow{\\partial_y},\\ \\overleftarrow{\\partial_z}$ | - shifted first derivative wrt $x,y,z$ | shifted 1/2 sample backward in space |\n", "| $\\omega_c = 2 \\pi f$ | center angular frequency | constant |\n", "| $b(x,y,z)$ | buoyancy $(1 / \\rho)$ | function of space |\n", "| $Q(x,y,z)$ | Attenuation at frequency $\\omega_c$ | function of space |\n", "| $m(x,y,z)$ | Total P wave velocity ($m_0+\\delta m$) | function of space |\n", "| $m_0(x,y,z)$ | Background P wave velocity | function of space |\n", "| $\\delta m(x,y,z)$ | Perturbation to P wave velocity | function of space |\n", "| $u(t,x,y,z)$ | Total pressure wavefield ($u_0+\\delta u$)| function of time and space |\n", "| $u_0(t,x,y,z)$ | Background pressure wavefield | function of time and space |\n", "| $\\delta u(t,x,y,z)$ | Perturbation to pressure wavefield | function of time and space |\n", "| $q(t,x,y,z)$ | Source wavefield | function of time, localized in space to source location |\n", "| $r(t,x,y,z)$ | Receiver wavefield | function of time, localized in space to receiver locations |\n", "| $F[m; q]$ | Forward nonlinear modeling operator | Nonlinear in $m$, linear in $q$: $\\quad$ maps $m \\rightarrow r$ |\n", "| $\\nabla F[m; q]\\ \\delta m$ | Forward Jacobian modeling operator | Linearized at $[m; q]$: $\\quad$ maps $\\delta m \\rightarrow \\delta r$ |\n", "| $\\bigl( \\nabla F[m; q] \\bigr)^\\top\\ \\delta r$ | Adjoint Jacobian modeling operator | Linearized at $[m; q]$: $\\quad$ maps $\\delta r \\rightarrow \\delta m$ |\n", "| $\\Delta_t, \\Delta_x, \\Delta_y, \\Delta_z$ | sampling rates for $t, x, y , z$ | $t, x, y , z$ | " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## A word about notation \n", "\n", "We use the arrow symbols over derivatives $\\overrightarrow{\\partial_x}$ as a shorthand notation to indicate that the derivative is taken at a shifted location. For example:\n", "\n", "- $\\overrightarrow{\\partial_x}\\ u(t,x,y,z)$ indicates that the $x$ derivative of $u(t,x,y,z)$ is taken at $u(t,x+\\frac{\\Delta x}{2},y,z)$.\n", "\n", "- $\\overleftarrow{\\partial_z}\\ u(t,x,y,z)$ indicates that the $z$ derivative of $u(t,x,y,z)$ is taken at $u(t,x,y,z-\\frac{\\Delta z}{2})$.\n", "\n", "- $\\overleftarrow{\\partial_t}\\ u(t,x,y,z)$ indicates that the $t$ derivative of $u(t,x,y,z)$ is taken at $u(t-\\frac{\\Delta_t}{2},x,y,z)$.\n", "\n", "We usually drop the $(t,x,y,z)$ notation from wavefield variables unless required for clarity of exposition, so that $u(t,x,y,z)$ becomes $u$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Nonlinear operator\n", "\n", "The nonlinear operator is the solution to the self adjoint scalar isotropic variable density visco- acoustic wave equation shown immediately below, and maps the velocity model vector $m$ into the receiver wavefield vector $r$.\n", "\n", "$$\n", "\\frac{b}{m^2} \\left( \\frac{\\omega_c}{Q}\\overleftarrow{\\partial_t}\\ u + \\partial_{tt}\\ u \\right) =\n", " \\overleftarrow{\\partial_x}\\left(b\\ \\overrightarrow{\\partial_x}\\ u \\right) +\n", " \\overleftarrow{\\partial_y}\\left(b\\ \\overrightarrow{\\partial_y}\\ u \\right) +\n", " \\overleftarrow{\\partial_z}\\left(b\\ \\overrightarrow{\\partial_z}\\ u \\right) + q\n", "$$\n", "\n", "In operator notation, where the operator is nonlinear with respect to model $m$ to the left of semicolon inside the square brackets, and linear with respect to the source $q$ to the right of semicolon inside the square brackets.\n", "\n", "$$\n", "F[m; q] = r\n", "$$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The Jacobian operator\n", "\n", "In this section we linearize about a background model and take the derivative of the nonlinear operator to obtain the Jacobian forward operator. \n", "\n", "In operator notation, where the derivative of the modeling operator is now linear in the model perturbation vector $\\delta m$, the Jacobian operator maps a perturbation in the velocity model $\\delta m$ into a perturbation in the receiver wavefield $\\delta r$.\n", "\n", "$$\n", "\\nabla F[m; q]\\ \\delta m = \\delta r\n", "$$\n", "\n", "#### 1. We begin by simplifying notation \n", "To simplify the treatment below we introduce the operator $L_t[\\cdot]$, accounting for the time derivatives inside the parentheses on the left hand side of the wave equation. \n", "\n", "$$\n", "L_t[\\cdot] \\equiv \\frac{\\omega_c}{Q} \\overleftarrow{\\partial_t}[\\cdot] + \\partial_{tt}[\\cdot]\n", "$$\n", "\n", "Next we re-write the wave equation using this notation.\n", "\n", "$$\n", "\\frac{b}{m^2} L_t[u] =\n", " \\overleftarrow{\\partial_x}\\left(b\\ \\overrightarrow{\\partial_x}\\ u \\right) +\n", " \\overleftarrow{\\partial_y}\\left(b\\ \\overrightarrow{\\partial_y}\\ u \\right) +\n", " \\overleftarrow{\\partial_z}\\left(b\\ \\overrightarrow{\\partial_z}\\ u \\right) + q\n", "$$\n", "\n", "#### 2. Linearize\n", "To linearize we treat the total model as the sum of background and perturbation models $\\left(m = m_0 + \\delta m\\right)$, and the total pressure as the sum of background and perturbation pressures $\\left(u = u_0 + \\delta u\\right)$.\n", "\n", "$$\n", "\\frac{b}{(m_0+\\delta m)^2} L_t[u_0+\\delta u] =\n", " \\overleftarrow{\\partial_x}\\left(b\\ \\overrightarrow{\\partial_x} (u_0+\\delta u) \\right) +\n", " \\overleftarrow{\\partial_y}\\left(b\\ \\overrightarrow{\\partial_y} (u_0+\\delta u) \\right) +\n", " \\overleftarrow{\\partial_z}\\left(b\\ \\overrightarrow{\\partial_z} (u_0+\\delta u) \\right) + q\n", "$$\n", "\n", "Note that *model parameters* for this variable density isotropic visco-acoustic physics is only velocity, we do not treat perturbations to density.\n", "\n", "We also write the PDE for the background model, which we subtract after linearization to simplify the final expression. \n", "\n", "$$\n", "\\frac{b}{m_0^2} L_t[u_0] =\n", " \\overleftarrow{\\partial_x}\\left(b\\ \\overrightarrow{\\partial_x} u_0 \\right) +\n", " \\overleftarrow{\\partial_y}\\left(b\\ \\overrightarrow{\\partial_y} u_0 \\right) +\n", " \\overleftarrow{\\partial_z}\\left(b\\ \\overrightarrow{\\partial_z} u_0 \\right) + q\n", "$$\n", "\n", "#### 3. Take derivative w.r.t. model parameters\n", "Next we take the derivative with respect to velocity, keep only terms up to first order in the perturbations, subtract the background model PDE equation, and finally arrive at the following linearized equation:\n", "\n", "$$\n", "\\frac{b}{m_0^2} L_t\\left[\\delta u\\right] =\n", " \\overleftarrow{\\partial_x}\\left(b\\ \\overrightarrow{\\partial_x} \\delta u \\right) +\n", " \\overleftarrow{\\partial_y}\\left(b\\ \\overrightarrow{\\partial_y} \\delta u \\right) +\n", " \\overleftarrow{\\partial_z}\\left(b\\ \\overrightarrow{\\partial_z} \\delta u \\right) + \n", " \\frac{2\\ b\\ \\delta m}{m_0^3} L_t\\left[u_0\\right]\n", "$$\n", "\n", "Note that the source $q$ in the original equation above has disappeared due to subtraction of the background PDE, and has been replaced by the *Born source*: \n", "\n", "$$\n", "q = \\frac{\\displaystyle 2\\ b\\ \\delta m}{\\displaystyle m_0^3} L_t\\left[u_0\\right]\n", "$$\n", "\n", "This is the same equation as used for the nonlinear forward, only now in the perturbed wavefield $\\delta u$ and with the Born source." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## The adjoint of the Jacobian operator\n", "\n", "In this section we introduce the adjoint of the Jacobian operator we derived above. The Jacobian adjoint operator maps a perturbation in receiver wavefield $\\delta r$ into a perturbation in velocity model $\\delta m$. In operator notation:\n", "\n", "$$\n", "\\bigl( \\nabla F[m; q] \\bigr)^\\top\\ \\delta r = \\delta m\n", "$$\n", "\n", "#### 1. Solve the time reversed wave equation with the receiver perturbation as source\n", "The PDE for the adjoint of the Jacobian is solved for the perturbation to the pressure wavefield $\\delta u$ by using the same wave equation as the nonlinear forward and the Jacobian forward, with the time reversed receiver wavefield perturbation $\\widetilde{\\delta r}$ injected as source. \n", "\n", "Note that we use $\\widetilde{\\delta u}$ and $\\widetilde{\\delta r}$ to indicate that we solve this finite difference evolution time reversed.\n", "\n", "$$\n", "\\frac{b}{m_0^2} L_t\\left[\\widetilde{\\delta u}\\right] =\n", " \\overleftarrow{\\partial_x}\\left(b\\ \\overrightarrow{\\partial_x}\\ \\widetilde{\\delta u} \\right) +\n", " \\overleftarrow{\\partial_y}\\left(b\\ \\overrightarrow{\\partial_y}\\ \\widetilde{\\delta u} \\right) +\n", " \\overleftarrow{\\partial_z}\\left(b\\ \\overrightarrow{\\partial_z}\\ \\widetilde{\\delta u} \\right) + \n", " \\widetilde{\\delta r}\n", "$$\n", "\n", "#### 2. Compute zero lag correlation \n", "\n", "We compute the perturbation to the velocity model by zero lag correlation of the wavefield perturbation $\\widetilde{\\delta u}$ solved in step 1 as shown in the following expression: \n", "\n", "$$\n", "\\delta m(x,y,z) = \\sum_t \n", " \\left\\{ \n", " \\widetilde{\\delta u}(t,x,y,z)\\ \n", " \\frac{\\displaystyle 2\\ b}{\\displaystyle m_0^3} L_t\\bigl[u_0(t,x,y,z)\\bigr]\n", " \\right\\}\n", "$$\n", "\n", "Note that this correlation can be more formally derived by examining the equations for two Green's functions, one for the background model ($m_0$) and wavefield ($u_0$), and one for for the total model $(m_0 + \\delta m)$ and wavefield $(u_0 + \\delta u)$, and subtracting to derive the equation for Born scattering.\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Implementation\n", "\n", "Next we assemble the Devito objects needed to implement these linearized operators." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Imports \n", "\n", "We have grouped all imports used in this notebook here for consistency." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "from examples.seismic import RickerSource, Receiver, TimeAxis\n", "from devito import (Grid, Function, TimeFunction, SpaceDimension, Constant, \n", " Eq, Operator, solve, configuration, norm)\n", "from devito.finite_differences import Derivative\n", "from devito.builtins import gaussian_smooth\n", "from examples.seismic.self_adjoint import setup_w_over_q\n", "import matplotlib as mpl\n", "import matplotlib.pyplot as plt\n", "from matplotlib import cm\n", "from timeit import default_timer as timer\n", "\n", "# These lines force images to be displayed in the notebook, and scale up fonts \n", "%matplotlib inline\n", "mpl.rc('font', size=14)\n", "\n", "# Make white background for plots, not transparent\n", "plt.rcParams['figure.facecolor'] = 'white'\n", "\n", "# We define 32 bit floating point as the precision type \n", "dtype = np.float32\n", "\n", "# Set logging to debug, captures statistics on the performance of operators\n", "# configuration['log-level'] = 'DEBUG'\n", "configuration['log-level'] = 'INFO'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Instantiate the Devito grid for a two dimensional problem\n", "\n", "We define the grid the same as in the previous notebook outlining implementation for the nonlinear forward." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "shape; (301, 301)\n", "origin; (0.0, 0.0)\n", "spacing; (10.0, 10.0)\n", "extent; (3000.0, 3000.0)\n", "\n", "shape_pad; [401 401]\n", "origin_pad; (-500.0, -500.0)\n", "extent_pad; (4000.0, 4000.0)\n", "\n", "grid.shape; (401, 401)\n", "grid.extent; (4000.0, 4000.0)\n", "grid.spacing_map; {h_x: 10.0, h_z: 10.0}\n" ] } ], "source": [ "# Define dimensions for the interior of the model\n", "nx,nz = 301,301\n", "dx,dz = 10.0,10.0 # Grid spacing in m\n", "shape = (nx, nz) # Number of grid points\n", "spacing = (dx, dz) # Domain size is now 5 km by 5 km\n", "origin = (0., 0.) # Origin of coordinate system, specified in m.\n", "extent = tuple([s*(n-1) for s, n in zip(spacing, shape)])\n", "\n", "# Define dimensions for the model padded with absorbing boundaries\n", "npad = 50 # number of points in absorbing boundary region (all sides)\n", "nxpad,nzpad = nx + 2 * npad, nz + 2 * npad\n", "shape_pad = np.array(shape) + 2 * npad\n", "origin_pad = tuple([o - s*npad for o, s in zip(origin, spacing)])\n", "extent_pad = tuple([s*(n-1) for s, n in zip(spacing, shape_pad)])\n", "\n", "# Define the dimensions \n", "# Note if you do not specify dimensions, you get in order x,y,z\n", "x = SpaceDimension(name='x', spacing=Constant(name='h_x', \n", " value=extent_pad[0]/(shape_pad[0]-1)))\n", "z = SpaceDimension(name='z', spacing=Constant(name='h_z', \n", " value=extent_pad[1]/(shape_pad[1]-1)))\n", "\n", "# Initialize the Devito grid \n", "grid = Grid(extent=extent_pad, shape=shape_pad, origin=origin_pad, \n", " dimensions=(x, z), dtype=dtype)\n", "\n", "print(\"shape; \", shape)\n", "print(\"origin; \", origin)\n", "print(\"spacing; \", spacing)\n", "print(\"extent; \", extent)\n", "print(\"\")\n", "print(\"shape_pad; \", shape_pad)\n", "print(\"origin_pad; \", origin_pad)\n", "print(\"extent_pad; \", extent_pad)\n", "\n", "print(\"\")\n", "print(\"grid.shape; \", grid.shape)\n", "print(\"grid.extent; \", grid.extent)\n", "print(\"grid.spacing_map;\", grid.spacing_map)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define velocity, buoyancy and $\\frac{\\omega_c}{Q}$ model parameters\n", "\n", "We have the following constants and fields to define:\n", "\n", "|   Symbol   | Description |\n", "|:---:|:---|\n", "| $$m0(x,z)$$ | Background velocity model |\n", "| $$\\delta m(x,z)$$ | Perturbation to velocity model |\n", "| $$b(x,z)=\\frac{1}{\\rho(x,z)}$$ | Buoyancy (reciprocal density) |\n", "| $$\\omega_c = 2 \\pi f_c$$ | Center angular frequency |\n", "| $$\\frac{1}{Q(x,z)}$$ | Inverse Q model used in the modeling system |\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Operator `WOverQ_Operator` run in 0.01 s\n" ] } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "\n", "# Create the velocity and buoyancy fields as in the nonlinear notebook \n", "space_order = 8\n", "\n", "# Wholespace velocity\n", "m0 = Function(name='m0', grid=grid, space_order=space_order)\n", "m0.data[:] = 1.5\n", "\n", "# Perturbation to velocity: a square offset from the center of the model\n", "dm = Function(name='dm', grid=grid, space_order=space_order)\n", "size = 10\n", "x0 = shape_pad[0]//2\n", "z0 = shape_pad[1]//2\n", "dm.data[:] = 0.0\n", "dm.data[x0-size:x0+size, z0-size:z0+size] = 1.0\n", "\n", "# Constant density\n", "b = Function(name='b', grid=grid, space_order=space_order)\n", "b.data[:,:] = 1.0 / 1.0\n", "\n", "# Initialize the attenuation profile for Q=100 model\n", "fpeak = 0.010\n", "w = 2.0 * np.pi * fpeak\n", "qmin = 0.1\n", "qmax = 1000.0\n", "wOverQ = Function(name='wOverQ', grid=grid, space_order=space_order)\n", "setup_w_over_q(wOverQ, w, qmin, 100.0, npad)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define the simulation time range and the acquisition geometry \n", "\n", "#### Simulation time range: \n", "\n", "In this notebook we run 3 seconds of simulation using the sample rate related to the CFL condition as implemented in ```examples/seismic/self_adjoint/utils.py```. \n", "\n", "We also use the convenience ```TimeRange``` as defined in ```examples/seismic/source.py```.\n", "\n", "#### Acquisition geometry: \n", "\n", "**source**:\n", "- X coordinate: left sode of model\n", "- Z coordinate: middle of model\n", "- We use a 10 Hz center frequency [RickerSource](https://github.com/devitocodes/devito/blob/master/examples/seismic/source.py#L280) wavelet source as defined in ```examples/seismic/source.py```\n", "\n", "**receivers**:\n", "- X coordinate: right side of model\n", "- Z coordinate: vertical line in model\n", "- We use a vertical line of [Receivers](https://github.com/devitocodes/devito/blob/master/examples/seismic/source.py#L80) as defined with a ```PointSource``` in ```examples/seismic/source.py```" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "def compute_critical_dt(v):\n", " \"\"\"\n", " Determine the temporal sampling to satisfy CFL stability.\n", " This method replicates the functionality in the Model class.\n", " Note we add a safety factor, reducing dt by a factor 0.75 due to the\n", " w/Q attentuation term.\n", " Parameters\n", " ----------\n", " v : Function\n", " velocity\n", " \"\"\"\n", " coeff = 0.38 if len(v.grid.shape) == 3 else 0.42\n", " dt = 0.75 * v.dtype(coeff * np.min(v.grid.spacing) / (np.max(v.data)))\n", " return v.dtype(\"%.5e\" % dt)" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Time min, max, dt, num; 0.000000 1200.000000 2.100000 572\n", "time_range; TimeAxis: start=0, stop=1201.2, step=2.1, num=573\n", "src_coordinate X; +752.0000\n", "src_coordinate Z; +1505.0000\n", "rec_coordinates X min/max; +2257.0000 +2257.0000\n", "rec_coordinates Z min/max; +0.0000 +3000.0000\n" ] } ], "source": [ "t0 = 0.0 # Simulation time start\n", "tn = 1200.0 # Simulation time end (1 second = 1000 msec)\n", "dt = compute_critical_dt(m0)\n", "time_range = TimeAxis(start=t0, stop=tn, step=dt)\n", "print(\"Time min, max, dt, num; %10.6f %10.6f %10.6f %d\" % (t0, tn, dt, int(tn//dt) + 1))\n", "print(\"time_range; \", time_range)\n", "\n", "# Source at 1/4 X, 1/2 Z, Ricker with 10 Hz center frequency\n", "src_nl = RickerSource(name='src_nl', grid=grid, f0=fpeak, npoint=1, time_range=time_range)\n", "src_nl.coordinates.data[0,0] = dx * 1 * nx//4\n", "src_nl.coordinates.data[0,1] = dz * shape[1]//2\n", "\n", "# Receivers at 3/4 X, line in Z\n", "rec_nl = Receiver(name='rec_nl', grid=grid, npoint=nz, time_range=time_range)\n", "rec_nl.coordinates.data[:,0] = dx * 3 * nx//4\n", "rec_nl.coordinates.data[:,1] = np.linspace(0.0, dz*(nz-1), nz)\n", "\n", "print(\"src_coordinate X; %+12.4f\" % (src_nl.coordinates.data[0,0]))\n", "print(\"src_coordinate Z; %+12.4f\" % (src_nl.coordinates.data[0,1]))\n", "print(\"rec_coordinates X min/max; %+12.4f %+12.4f\" % \\\n", " (np.min(rec_nl.coordinates.data[:,0]), np.max(rec_nl.coordinates.data[:,0])))\n", "print(\"rec_coordinates Z min/max; %+12.4f %+12.4f\" % \\\n", " (np.min(rec_nl.coordinates.data[:,1]), np.max(rec_nl.coordinates.data[:,1])))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plot the model \n", "\n", "We plot the following ```Functions```:\n", "- Background Velocity\n", "- Background Density\n", "- Velocity perturbation\n", "- Q Model\n", "\n", "Each subplot also shows:\n", "- The location of the absorbing boundary as a dotted line\n", "- The source location as a red star\n", "- The line of receivers as a black vertical line" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# NBVAL_INGNORE_OUTPUT\n", "\n", "# Note: flip sense of second dimension to make the plot positive downwards\n", "plt_extent = [origin_pad[0], origin_pad[0] + extent_pad[0],\n", " origin_pad[1] + extent_pad[1], origin_pad[1]]\n", "\n", "vmin, vmax = 1.5, 2.0\n", "pmin, pmax = -1, +1\n", "bmin, bmax = 0.9, 1.1\n", "\n", "q = w / wOverQ.data[:]\n", "\n", "x1 = 0.0\n", "x2 = dx * nx\n", "z1 = 0.0\n", "z2 = dz * nz\n", "abcX = [x1,x1,x2,x2,x1]\n", "abcZ = [z1,z2,z2,z1,z1]\n", "\n", "plt.figure(figsize=(12,12))\n", "\n", "plt.subplot(2, 2, 1)\n", "plt.imshow(np.transpose(m0.data), cmap=cm.jet, \n", " vmin=vmin, vmax=vmax, extent=plt_extent)\n", "plt.plot(abcX, abcZ, 'gray', linewidth=4, linestyle=':', label=\"Absorbing Boundary\")\n", "plt.plot(src_nl.coordinates.data[:, 0], src_nl.coordinates.data[:, 1], \\\n", " 'red', linestyle='None', marker='*', markersize=15, label=\"Source\")\n", "plt.plot(rec_nl.coordinates.data[:, 0], rec_nl.coordinates.data[:, 1], \\\n", " 'black', linestyle='None', marker='^', markersize=2, label=\"Receivers\")\n", "plt.colorbar(orientation='horizontal', label='Velocity (m/msec)')\n", "plt.xlabel(\"X Coordinate (m)\")\n", "plt.ylabel(\"Z Coordinate (m)\")\n", "plt.title(\"Background Velocity\")\n", "\n", "plt.subplot(2, 2, 2)\n", "plt.imshow(np.transpose(1 / b.data), cmap=cm.jet,\n", " vmin=bmin, vmax=bmax, extent=plt_extent)\n", "plt.plot(abcX, abcZ, 'gray', linewidth=4, linestyle=':', label=\"Absorbing Boundary\")\n", "plt.plot(src_nl.coordinates.data[:, 0], src_nl.coordinates.data[:, 1], \\\n", " 'red', linestyle='None', marker='*', markersize=15, label=\"Source\")\n", "plt.plot(rec_nl.coordinates.data[:, 0], rec_nl.coordinates.data[:, 1], \\\n", " 'black', linestyle='None', marker='^', markersize=2, label=\"Receivers\")\n", "plt.colorbar(orientation='horizontal', label='Density (kg/m^3)')\n", "plt.xlabel(\"X Coordinate (m)\")\n", "plt.ylabel(\"Z Coordinate (m)\")\n", "plt.title(\"Background Density\")\n", "\n", "plt.subplot(2, 2, 3)\n", "plt.imshow(np.transpose(dm.data), cmap=\"seismic\", \n", " vmin=pmin, vmax=pmax, extent=plt_extent)\n", "plt.plot(abcX, abcZ, 'gray', linewidth=4, linestyle=':', label=\"Absorbing Boundary\")\n", "plt.plot(src_nl.coordinates.data[:, 0], src_nl.coordinates.data[:, 1], \\\n", " 'red', linestyle='None', marker='*', markersize=15, label=\"Source\")\n", "plt.plot(rec_nl.coordinates.data[:, 0], rec_nl.coordinates.data[:, 1], \\\n", " 'black', linestyle='None', marker='^', markersize=2, label=\"Receivers\")\n", "plt.colorbar(orientation='horizontal', label='Velocity (m/msec)')\n", "plt.xlabel(\"X Coordinate (m)\")\n", "plt.ylabel(\"Z Coordinate (m)\")\n", "plt.title(\"Velocity Perturbation\")\n", "\n", "plt.subplot(2, 2, 4)\n", "plt.imshow(np.transpose(np.log10(q.data)), cmap=cm.jet,\n", " vmin=np.log10(qmin), vmax=np.log10(qmax), extent=plt_extent)\n", "plt.plot(abcX, abcZ, 'white', linewidth=4, linestyle=':', label=\"Absorbing Boundary\")\n", "plt.plot(src_nl.coordinates.data[:, 0], src_nl.coordinates.data[:, 1], \\\n", " 'red', linestyle='None', marker='*', markersize=15, label=\"Source\")\n", "plt.plot(rec_nl.coordinates.data[:, 0], rec_nl.coordinates.data[:, 1], \\\n", " 'black', linestyle='None', marker='^', markersize=2, label=\"Receivers\")\n", "plt.colorbar(orientation='horizontal', label='log10 $Q_p$')\n", "plt.xlabel(\"X Coordinate (m)\")\n", "plt.ylabel(\"Z Coordinate (m)\")\n", "plt.title(\"log10 of $Q_p$ Profile\")\n", "\n", "plt.tight_layout()\n", "None" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Define pressure wavefields\n", "\n", "We need two wavefields for Jacobian operations, one computed during the finite difference evolution of the nonlinear forward operator $u_0(t,x,z)$, and one computed during the finite difference evolution of the Jacobian operator $\\delta u(t,x,z)$. \n", "\n", "For this example workflow we will require saving all time steps from the nonlinear forward operator for use in the Jacobian operators. There are other ways to implement this requirement, including checkpointing, but that is way outside the scope of this illustrative workflow. " ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Define the TimeFunctions for nonlinear and Jacobian operations\n", "nt = time_range.num\n", "u0 = TimeFunction(name=\"u0\", grid=grid, time_order=2, space_order=space_order, save=nt)\n", "duFwd = TimeFunction(name=\"duFwd\", grid=grid, time_order=2, space_order=space_order, save=None)\n", "duAdj = TimeFunction(name=\"duAdj\", grid=grid, time_order=2, space_order=space_order, save=None)\n", "\n", "# Get the dimensions for t, x, z \n", "t,x,z = u0.dimensions" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Implement and run the nonlinear operator\n", "\n", "We next transcribe the time update expression for the nonlinear operator above into a Devito ```Eq```. Then we add the source injection and receiver extraction and build an ```Operator``` that will generate the c code for performing the modeling.\n", "\n", "We copy the time update expression from the first implementation notebook, but omit the source term $q$ because for the nonlinear operator we explicitly inject the source using ```src_term```. \n", "\n", "We think of this as solving for the *background wavefield* $u_0$ not the total wavefield $u$, and hence we use $v_0$ for velocity instead of $v$.\n", "\n", "$$\n", "\\begin{aligned}\n", " u_0(t+\\Delta_t) &=\n", " \\frac{\\Delta_t^2 v_0^2}{b} \\left[ \n", " \\overleftarrow{\\partial_x}\\left(b\\ \\overrightarrow{\\partial_x}\\ u_0 \\right) +\n", " \\overleftarrow{\\partial_y}\\left(b\\ \\overrightarrow{\\partial_y}\\ u_0 \\right) +\n", " \\overleftarrow{\\partial_z}\\left(b\\ \\overrightarrow{\\partial_z}\\ u_0 \\right) + q\n", " \\right] \\\\[5pt]\n", " &\\quad +\\ u_0(t) \\left(2 - \\frac{\\Delta_t^2 \\omega_c}{Q} \\right)\n", " - u_0(t-\\Delta_t) \\left(1 - \\frac{\\Delta_t\\ \\omega_c}{Q} \\right)\n", "\\end{aligned}\n", "$$\n", "\n", "## Self adjoint means support for nonlinear and linearized ops\n", "Note that this stencil can be used for all of the operations we need, modulo the different source terms for the nonlinear and linearized forward evolutions:\n", "1. the nonlinear forward (solved forward in time, $q$ is the usual source )\n", "2. the Jacobian forward (solved forward in time, $q$ is the Born source )\n", "3. the Jacobian adjoint (solved backward in time, $q$ is the time reversed receiver wavefield)\n", "\n", "## Source injection and receiver extraction for nonlinear forward operator\n", "\n", "Source injection and receiver extraction follow the implementation shown in the first notebook, please refer there for more information. " ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "spacing_map; {h_x: 10.0, h_z: 10.0, dt: 2.1}\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ "Operator `Kernel` run in 0.38 s\n" ] } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "\n", "# The nonlinear forward time update equation\n", "eq_time_update_nl_fwd = (t.spacing**2 * m0**2 / b) * \\\n", " ((b * u0.dx(x0=x+x.spacing/2)).dx(x0=x-x.spacing/2) +\n", " (b * u0.dz(x0=z+z.spacing/2)).dz(x0=z-z.spacing/2)) + \\\n", " (2 - t.spacing * wOverQ) * u0 + \\\n", " (t.spacing * wOverQ - 1) * u0.backward\n", "\n", "stencil_nl = Eq(u0.forward, eq_time_update_nl_fwd)\n", "\n", "# Update the dimension spacing_map to include the time dimension\n", "# Please refer to the first implementation notebook for more information\n", "spacing_map = grid.spacing_map\n", "spacing_map.update({t.spacing : dt})\n", "print(\"spacing_map; \", spacing_map)\n", "\n", "# Source injection and Receiver extraction\n", "src_term_nl = src_nl.inject(field=u0.forward, expr=src_nl * t.spacing**2 * m0**2 / b)\n", "rec_term_nl = rec_nl.interpolate(expr=u0.forward)\n", "\n", "# Instantiate and run the operator for the nonlinear forward\n", "op_nl = Operator([stencil_nl] + src_term_nl + rec_term_nl, subs=spacing_map)\n", "u0.data[:] = 0\n", "op_nl.apply()\n", "None" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# Continuous integration hooks \n", "# We ensure the norm of these computed wavefields is repeatable\n", "# print(norm(u0))\n", "assert np.isclose(norm(u0), 3098.012, atol=0, rtol=1e-2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Implement and run the Jacobian forward operator\n", "\n", "We next transcribe the time update expression for the linearized operator into a Devito ```Eq```. Note that the source injection for the linearized operator is very different, and involves the Born source derived above *everywhere in space*. \n", "\n", "Please refer to the first notebook for the derivation of the time update equation if you don't follow this step.\n", "\n", "$$\n", "\\begin{aligned}\n", " \\delta u(t+\\Delta_t) &=\n", " \\frac{\\Delta_t^2 v_0^2}{b} \\left[ \n", " \\overleftarrow{\\partial_x}\\left(b\\ \\overrightarrow{\\partial_x}\\ \\delta u \\right) +\n", " \\overleftarrow{\\partial_y}\\left(b\\ \\overrightarrow{\\partial_y}\\ \\delta u \\right) +\n", " \\overleftarrow{\\partial_z}\\left(b\\ \\overrightarrow{\\partial_z}\\ \\delta u \\right) + q\n", " \\right] \\\\[5pt]\n", " &\\quad +\\ \\delta u(t) \\left(2 - \\frac{\\Delta_t^2 \\omega_c}{Q} \\right)\n", " - \\delta u(t-\\Delta_t) \\left(1 - \\frac{\\Delta_t\\ \\omega_c}{Q} \\right) \\\\[10pt]\n", " q &= \\frac{2\\ b\\ \\delta m}{m_0^3} L_t\\left[u_0\\right]\n", "\\end{aligned}\n", "$$\n", "\n", "## Source injection and receiver extraction for linearized forward operator\n", "\n", "Note the source for the linearized forward operator is the Born source $q$, so we do not require a source injection term as with the nonlinear operator. \n", "\n", "As this is a forward operator, we are mapping into receiver gathers and therefore need to define both a container and an extraction term for receiver data.\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Operator `Kernel` run in 0.46 s\n" ] } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "\n", "# The linearized forward time update equation\n", "eq_time_update_ln_fwd = (t.spacing**2 * m0**2 / b) * \\\n", " ((b * duFwd.dx(x0=x+x.spacing/2)).dx(x0=x-x.spacing/2) +\n", " (b * duFwd.dz(x0=z+z.spacing/2)).dz(x0=z-z.spacing/2) + \n", " 2 * b * dm * m0**-3 * (wOverQ * u0.dt(x0=t-t.spacing/2) + u0.dt2)) +\\\n", " (2 - t.spacing * wOverQ) * duFwd + \\\n", " (t.spacing * wOverQ - 1) * duFwd.backward\n", "\n", "stencil_ln_fwd = Eq(duFwd.forward, eq_time_update_ln_fwd)\n", "\n", "# Receiver container and receiver extraction for the linearized operator\n", "rec_ln = Receiver(name='rec_ln', grid=grid, npoint=nz, time_range=time_range)\n", "rec_ln.coordinates.data[:,:] = rec_nl.coordinates.data[:,:]\n", "rec_term_ln_fwd = rec_ln.interpolate(expr=duFwd.forward)\n", "\n", "# Instantiate and run the operator for the linearized forward\n", "op_ln_fwd = Operator([stencil_ln_fwd] + rec_term_ln_fwd, subs=spacing_map)\n", "duFwd.data[:] = 0\n", "op_ln_fwd.apply()\n", "None" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "# Continuous integration hooks \n", "# We ensure the norm of these computed wavefields is repeatable\n", "# print(norm(duFwd))\n", "assert np.isclose(norm(duFwd), 227.063, atol=0, rtol=1e-3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plot the computed nonlinear and linearized forward wavefields\n", "\n", "Below we show the nonlinear and Born scattered wavefields at the end of the finite difference evolution. You can clearly see both forward and backward scattered energy from the velocity perturbation in the linearized forward (Born) wavefield, with appropriate polatiry reversals in the events. " ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "amax nl; 1.607968\n", "amax ln t=1.20s; 0.704292\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "\n", "# Plot the two wavefields, each normalized to own maximum\n", "kt = nt - 2\n", "\n", "amax_nl = 1.0 * np.max(np.abs(u0.data[kt,:,:]))\n", "amax_ln = 0.1 * np.max(np.abs(duFwd.data[kt,:,:]))\n", "\n", "print(\"amax nl; %12.6f\" % (amax_nl))\n", "print(\"amax ln t=%.2fs; %12.6f\" % (dt * kt / 1000, amax_ln))\n", "\n", "plt.figure(figsize=(12,12))\n", "\n", "plt.subplot(1, 2, 1)\n", "plt.imshow(np.transpose(u0.data[kt,:,:]), cmap=\"seismic\", \n", " vmin=-amax_nl, vmax=+amax_nl, extent=plt_extent)\n", "plt.colorbar(orientation='horizontal', label='Amplitude')\n", "plt.plot(abcX, abcZ, 'gray', linewidth=4, linestyle=':', label=\"Absorbing Boundary\")\n", "plt.plot(src_nl.coordinates.data[:, 0], src_nl.coordinates.data[:, 1], \\\n", " 'red', linestyle='None', marker='*', markersize=15, label=\"Source\")\n", "plt.plot(rec_nl.coordinates.data[:, 0], rec_nl.coordinates.data[:, 1], \\\n", " 'black', linestyle='None', marker='^', markersize=2, label=\"Receivers\")\n", "plt.xlabel(\"X Coordinate (m)\")\n", "plt.ylabel(\"Z Coordinate (m)\")\n", "plt.title(\"Nonlinear wavefield at t=%.2fs\" % (dt * kt / 1000))\n", "\n", "plt.subplot(1, 2, 2)\n", "plt.imshow(np.transpose(duFwd.data[kt,:,:]), cmap=\"seismic\",\n", " vmin=-amax_ln, vmax=+amax_ln, extent=plt_extent)\n", "plt.colorbar(orientation='horizontal', label='Amplitude')\n", "plt.plot(abcX, abcZ, 'gray', linewidth=4, linestyle=':', label=\"Absorbing Boundary\")\n", "plt.plot(src_nl.coordinates.data[:, 0], src_nl.coordinates.data[:, 1], \\\n", " 'red', linestyle='None', marker='*', markersize=15, label=\"Source\")\n", "plt.plot(rec_nl.coordinates.data[:, 0], rec_nl.coordinates.data[:, 1], \\\n", " 'black', linestyle='None', marker='^', markersize=2, label=\"Receivers\")\n", "plt.xlabel(\"X Coordinate (m)\")\n", "plt.ylabel(\"Z Coordinate (m)\")\n", "plt.title(\"Born wavefield at t=%.2fs\" % (dt * kt / 1000))\n", "\n", "plt.tight_layout()\n", "None" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## An alternative implementation for the linearized forward\n", "\n", "We would like to acknowledge Mathias Louboutin for an alternative method of implementing the linearized forward operator that is very efficient and perhaps novel. The driver code that implements the Jacobian forward operator (```examples/seismic/self_adjoint/operators.py```) can solve for both the nonlinear and linearized finite difference evolutions simultaneously. This implies significant performance gains with respect to cache pressure.\n", "\n", "We outline below this code for your enjoyment, with line numbers added:\n", "\n", "```\n", "01 # Time update equations for nonlinear and linearized operators\n", "02 eqn1 = iso_stencil(u0, model, forward=True)\n", "03 eqn2 = iso_stencil(du, model, forward=True,\n", "04 q=2 * b * dm * v**-3 * (wOverQ * u0.dt(x0=t-t.spacing/2) + u0.dt2))\n", "05\n", "06 # Inject the source into the nonlinear wavefield at u0(t+dt)\n", "07 src_term = src.inject(field=u0.forward, expr=src * t.spacing**2 * v**2 / b)\n", "08 \n", "09 # Extract receiver wavefield from the linearized wavefield, at du(t)\n", "10 rec_term = rec.interpolate(expr=du)\n", "11 \n", "12 # Create the operator\n", "13 Operator(eqn1 + src_term + eqn2 + rec_term, subs=spacing_map,\n", "14 name='ISO_JacobianFwdOperator', **kwargs)\n", "```\n", "\n", "One important thing to note about this code is the precedence of operations specified on the construction of the operator at line 13. It is guaranteed by Devito that ```eqn1``` will 'run' before ```eqn2```. This means that this specific order will occurr in the generated code: \n", "1. The nonlinear wavefield is advanced in time\n", "2. The nonlinear source is injected in the nonlinear wavefield\n", "3. The linearized wavefield is advanced in time\n", "4. The linearixzed wavefield is interpolated at the receiever locations\n", "\n", "As an exercise, you might implement this operator and print the generated c code to confirm this. " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Implement and run the Jacobian adjoint operator\n", "\n", "The linearized Jacobian adjoint uses the same time update equation as written above so we do not reproduce it here. Note that the finite difference evolution for the Jacobian adjoint runs *time-reversed* and a receiver wavefield is injected as source term. For this example we will inject the recorded linearized wavefield, which will provide an \"image\" of the Born scatterer. \n", "\n", "## Zero lag temporal correlation to build image\n", "\n", "We rewrite the zero lag temporal correlation that builds up the image from above. The sum is achieved in Devito via ```Eq(dm, dm + <...>)```, where ```<...>``` is the operand of the zero lag correlation shown immediately below.\n", "\n", "$$\n", "\\delta m(x,y,z) = \\sum_t \n", " \\left\\{ \n", " \\widetilde{\\delta u}(t,x,y,z)\\ \n", " \\frac{\\displaystyle 2\\ b}{\\displaystyle m_0^3} L_t\\left[u_0(t,x,y,z)\\right]\n", " \\right\\}\n", "$$\n", "\n", "Note we instantiate a new ```Function``` $dm_a$ to hold the output from the linearized adjoint operator. \n", "\n", "## Source injection and receiver extraction for linearized adjoint operator\n", "\n", "Note the source for the linearized adjoint operator is the receiver wavefield, injected time-reversed.\n", "\n", "As this is an adjoint operator, we are mapping into the model domain and therefore do not need to define receivers." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Operator `Kernel` run in 0.47 s\n" ] } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "\n", "# New Function to hold the output from the adjoint\n", "dmAdj = Function(name='dmAdj', grid=grid, space_order=space_order)\n", "\n", "# The linearized adjoint time update equation\n", "# Note the small differencess from the linearized forward above\n", "eq_time_update_ln_adj = (t.spacing**2 * m0**2 / b) * \\\n", " ((b * duAdj.dx(x0=x+x.spacing/2)).dx(x0=x-x.spacing/2) +\n", " (b * duAdj.dz(x0=z+z.spacing/2)).dz(x0=z-z.spacing/2)) +\\\n", " (2 - t.spacing * wOverQ) * duAdj + \\\n", " (t.spacing * wOverQ - 1) * duAdj.forward\n", "\n", "stencil_ln_adj = Eq(duAdj.backward, eq_time_update_ln_adj)\n", "\n", "# Equation to sum the zero lag correlation\n", "dm_update = Eq(dmAdj, dmAdj +\n", " duAdj * (2 * b * m0**-3 * (wOverQ * u0.dt(x0=t-t.spacing/2) + u0.dt2)))\n", "\n", "# Receiver injection, time reversed\n", "rec_term_ln_adj = rec_ln.inject(field=duAdj.backward, expr=rec_ln * t.spacing**2 * m0**2 / b)\n", "\n", "# Instantiate and run the operator for the linearized forward\n", "op_ln_adj = Operator([dm_update] + [stencil_ln_adj] + rec_term_ln_adj, subs=spacing_map)\n", "op_ln_adj.apply()\n", "None" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [], "source": [ "# Continuous integration hooks \n", "# We ensure the norm of these computed wavefields is repeatable\n", "# print(norm(duAdj))\n", "assert np.isclose(norm(duAdj), 19218.924, atol=0, rtol=1e-3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Plot the image\n", "\n", "Below we plot the velocity perturbation and the \"image\" recovered from the linearized Jacobian adjoint. We normalize both fields to their maximum absolute value.\n", "\n", "Note that with a single source and this transmission geometry, we should expect to see significant horizontal smearing in the image. " ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "amax dm; 5.000000e-01\n", "amax dmAdj 4.128163e+02\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# NBVAL_IGNORE_OUTPUT\n", "\n", "amax1 = 0.5 * np.max(np.abs(dm.data[:]))\n", "amax2 = 0.5 * np.max(np.abs(dmAdj.data[:]))\n", "\n", "print(\"amax dm; %12.6e\" % (amax1))\n", "print(\"amax dmAdj %12.6e\" % (amax2))\n", "\n", "dm.data[:] = dm.data / amax1\n", "dmAdj.data[:] = dmAdj.data / amax2\n", "\n", "plt.figure(figsize=(12,8))\n", "\n", "plt.subplot(1, 2, 1)\n", "plt.imshow(np.transpose(dm.data), cmap=\"seismic\", \n", " vmin=-1, vmax=+1, extent=plt_extent, aspect=\"auto\")\n", "plt.plot(abcX, abcZ, 'gray', linewidth=4, linestyle=':', label=\"Absorbing Boundary\")\n", "plt.plot(src_nl.coordinates.data[:, 0], src_nl.coordinates.data[:, 1], \\\n", " 'red', linestyle='None', marker='*', markersize=15, label=\"Source\")\n", "plt.plot(rec_nl.coordinates.data[:, 0], rec_nl.coordinates.data[:, 1], \\\n", " 'black', linestyle='None', marker='^', markersize=2, label=\"Receivers\")\n", "plt.colorbar(orientation='horizontal', label='Velocity (m/msec)')\n", "plt.xlabel(\"X Coordinate (m)\")\n", "plt.ylabel(\"Z Coordinate (m)\")\n", "plt.title(\"Velocity Perturbation\")\n", "\n", "plt.subplot(1, 2, 2)\n", "plt.imshow(np.transpose(dmAdj.data), cmap=\"seismic\", \n", " vmin=-1, vmax=+1, extent=plt_extent, aspect=\"auto\")\n", "plt.plot(abcX, abcZ, 'gray', linewidth=4, linestyle=':', label=\"Absorbing Boundary\")\n", "plt.plot(src_nl.coordinates.data[:, 0], src_nl.coordinates.data[:, 1], \\\n", " 'red', linestyle='None', marker='*', markersize=15, label=\"Source\")\n", "plt.plot(rec_nl.coordinates.data[:, 0], rec_nl.coordinates.data[:, 1], \\\n", " 'black', linestyle='None', marker='^', markersize=2, label=\"Receivers\")\n", "plt.colorbar(orientation='horizontal', label='Velocity (m/msec)')\n", "plt.xlabel(\"X Coordinate (m)\")\n", "plt.ylabel(\"Z Coordinate (m)\")\n", "plt.title(\"Output from Jacobian adjoint\")\n", "\n", "plt.tight_layout()\n", "None" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Discussion\n", "\n", "This concludes the implementation of the linearized Jacobian forward and adjoint operators. \n", "\n", "Please note there are details critical for practical use of these tools missing from this demonstration. In particular, for practical application to industry scale problems there would need to be a mechanism to save or checkpoint the wavefield from the nonlinear forward for use in the linearized finite difference evolutions. \n", "\n", "Please continue with the final notebook in this series concerning the correctness testing of these operators. \n", "\n", "[sa_03_iso_correctness.ipynb](sa_03_iso_correctness.ipynb)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## References\n", "\n", "- **A nonreflecting boundary condition for discrete acoustic and elastic wave equations** (1985)\n", "
Charles Cerjan, Dan Kosloff, Ronnie Kosloff, and Moshe Resheq\n", "
Geophysics, Vol. 50, No. 4\n", "
https://library.seg.org/doi/pdfplus/10.1190/segam2016-13878451.1\n", "\n", "- **Generation of Finite Difference Formulas on Arbitrarily Spaced Grids** (1988)\n", "
Bengt Fornberg\n", "
Mathematics of Computation, Vol. 51, No. 184\n", "
http://dx.doi.org/10.1090/S0025-5718-1988-0935077-0\n", "
https://web.njit.edu/~jiang/math712/fornberg.pdf\n", "\n", "- **Self-adjoint, energy-conserving second-order pseudoacoustic systems for VTI and TTI media for reverse time migration and full-waveform inversion** (2016)\n", "
Kenneth Bube, John Washbourne, Raymond Ergas, and Tamas Nemeth\n", "
SEG Technical Program Expanded Abstracts\n", "
https://library.seg.org/doi/10.1190/segam2016-13878451.1\n" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "anaconda-cloud": {}, "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.8.3" } }, "nbformat": 4, "nbformat_minor": 4 }