{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# The Devito domain specific language: an overview\n", "\n", "This notebook presents an overview of the Devito symbolic language, used to express and discretise operators, in particular partial differential equations (PDEs).\n", "\n", "For convenience, we import all Devito modules:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from devito import *" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## From equations to code in a few lines of Python\n", "\n", "The main objective of this tutorial is to demonstrate how Devito and its [SymPy](http://www.sympy.org/en/index.html)-powered symbolic API can be used to solve partial differential equations using the finite difference method with highly optimized stencils in a few lines of Python. We demonstrate how computational stencils can be derived directly from the equation in an automated fashion and how Devito can be used to generate and execute, at runtime, the desired numerical scheme in the form of optimized C code.\n", "\n", "\n", "## Defining the physical domain\n", "\n", "Before we can begin creating finite-difference (FD) stencils we will need to give Devito a few details regarding the computational domain within which we wish to solve our problem. For this purpose we create a `Grid` object that stores the physical `extent` (the size) of our domain and knows how many points we want to use in each dimension to discretise our data.\n", "\n", "" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Grid[extent=(1.0, 1.0), shape=(5, 6), dimensions=(x, y)]" ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" } ], "source": [ "grid = Grid(shape=(5, 6), extent=(1., 1.))\n", "grid" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Functions and data\n", "\n", "To express our equation in symbolic form and discretise it using finite differences, Devito provides a set of `Function` types. A `Function` object:\n", "\n", "1. Behaves like a `sympy.Function` symbol\n", "2. Manages data associated with the symbol\n", "\n", "To get more information on how to create and use a `Function` object, or any type provided by Devito, we can take a look at the documentation." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", " Tensor symbol representing a discrete function in symbolic equations.\n", "\n", " A Function carries multi-dimensional data and provides operations to create\n", " finite-differences approximations.\n", "\n", " A Function encapsulates space-varying data; for data that also varies in time,\n", " use TimeFunction instead.\n", "\n", " Parameters\n", " ----------\n", " name : str\n", " Name of the symbol.\n", " grid : Grid, optional\n", " Carries shape, dimensions, and dtype of the Function. When grid is not\n", " provided, shape and dimensions must be given. For MPI execution, a\n", " Grid is compulsory.\n", " space_order : int or 3-tuple of ints, optional, default=1\n", " Discretisation order for space derivatives.\n", " `space_order` also impacts the number of points available around a\n", " generic point of interest. By default, `space_order` points are\n", " available on both sides of a generic point of interest, including those\n", " nearby the grid boundary. Sometimes, fewer points suffice; in other\n", " scenarios, more points are necessary. In such cases, instead of an\n", " integer, one can pass:\n", " * a 3-tuple `(o, lp, rp)` indicating the discretization order\n", " (`o`) as well as the number of points on the left (`lp`) and\n", " right (`rp`) sides of a generic point of interest;\n", " * a 2-tuple `(o, ((lp0, rp0), (lp1, rp1), ...))` indicating the\n", " discretization order (`o`) as well as the number of points on\n", " the left/right sides of a generic point of interest for each\n", " SpaceDimension.\n", " shape : tuple of ints, optional\n", " Shape of the domain region in grid points. Only necessary if `grid`\n", " isn't given.\n", " dimensions : tuple of Dimension, optional\n", " Dimensions associated with the object. Only necessary if `grid` isn't\n", " given.\n", " dtype : data-type, optional, default=np.float32\n", " Any object that can be interpreted as a numpy data type.\n", " staggered : Dimension or tuple of Dimension or Stagger, optional, default=None\n", " Define how the Function is staggered.\n", " initializer : callable or any object exposing the buffer interface, default=None\n", " Data initializer. If a callable is provided, data is allocated lazily.\n", " allocator : MemoryAllocator, optional\n", " Controller for memory allocation. To be used, for example, when one wants\n", " to take advantage of the memory hierarchy in a NUMA architecture. Refer to\n", " `default_allocator.__doc__` for more information.\n", " padding : int or tuple of ints, optional\n", " Allocate extra grid points to maximize data access alignment. When a tuple\n", " of ints, one int per Dimension should be provided.\n", "\n", " Examples\n", " --------\n", " Creation\n", "\n", " >>> from devito import Grid, Function\n", " >>> grid = Grid(shape=(4, 4))\n", " >>> f = Function(name='f', grid=grid)\n", " >>> f\n", " f(x, y)\n", " >>> g = Function(name='g', grid=grid, space_order=2)\n", " >>> g\n", " g(x, y)\n", "\n", " First-order derivatives through centered finite-difference approximations\n", "\n", " >>> f.dx\n", " Derivative(f(x, y), x)\n", " >>> f.dy\n", " Derivative(f(x, y), y)\n", " >>> g.dx\n", " Derivative(g(x, y), x)\n", " >>> (f + g).dx\n", " Derivative(f(x, y) + g(x, y), x)\n", "\n", " First-order derivatives through left/right finite-difference approximations\n", "\n", " >>> f.dxl\n", " Derivative(f(x, y), x)\n", "\n", " Note that the fact that it's a left-derivative isn't captured in the representation.\n", " However, upon derivative expansion, this becomes clear\n", "\n", " >>> f.dxl.evaluate\n", " f(x, y)/h_x - f(x - h_x, y)/h_x\n", " >>> f.dxr\n", " Derivative(f(x, y), x)\n", "\n", " Second-order derivative through centered finite-difference approximation\n", "\n", " >>> g.dx2\n", " Derivative(g(x, y), (x, 2))\n", "\n", " Notes\n", " -----\n", " The parameters must always be given as keyword arguments, since SymPy\n", " uses `*args` to (re-)create the dimension arguments of the symbolic object.\n", " \n" ] } ], "source": [ "print(Function.__doc__)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ok, let's create a function $f(x, y)$ and look at the data Devito has associated with it. Please note that it is important to use explicit keywords, such as `name` or `grid` when creating `Function` objects." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle f(x, y)$" ], "text/plain": [ "f(x, y)" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f = Function(name='f', grid=grid)\n", "f" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Data([[0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0.],\n", " [0., 0., 0., 0., 0., 0.]], dtype=float32)" ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f.data" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "By default, Devito `Function` objects use the spatial dimensions `(x, y)` for 2D grids and `(x, y, z)` for 3D grids. To solve a PDE over several timesteps a time dimension is also required by our symbolic function. For this Devito provides an additional function type, the `TimeFunction`, which incorporates the correct dimension along with some other intricacies needed to create a time stepping scheme." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle g(t, x, y)$" ], "text/plain": [ "g(t, x, y)" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g = TimeFunction(name='g', grid=grid)\n", "g" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Since the default time order of a `TimeFunction` is `1`, the shape of `f` is `(2, 5, 6)`, i.e. Devito has allocated two buffers to represent `g(t, x, y)` and `g(t + dt, x, y)`:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(2, 5, 6)" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Derivatives of symbolic functions\n", "\n", "The functions we have created so far all act as `sympy.Function` objects, which means that we can form symbolic derivative expressions from them. Devito provides a set of shorthand expressions (implemented as Python properties) that allow us to generate finite differences in symbolic form. For example, the property `f.dx` denotes $\\frac{\\partial}{\\partial x} f(x, y)$ - only that Devito has already discretised it with a finite difference expression. There are also a set of shorthand expressions for left (backward) and right (forward) derivatives:\n", "\n", "| Derivative | Shorthand | Discretised | Stencil |\n", "| ---------- |:---------:|:-----------:|:-------:|\n", "| $\\frac{\\partial}{\\partial x}f(x, y)$ (right) | `f.dxr` | $\\frac{f(x+h_x,y)}{h_x} - \\frac{f(x,y)}{h_x}$ | |\n", "| $\\frac{\\partial}{\\partial x}f(x, y)$ (left) | `f.dxl` | $\\frac{f(x,y)}{h_x} - \\frac{f(x-h_x,y)}{h_x}$ | |\n", "\n", "A similar set of expressions exist for each spatial dimension defined on our grid, for example `f.dy` and `f.dyl`. Obviously, one can also take derivatives in time of `TimeFunction` objects. For example, to take the first derivative in time of `g` you can simply write:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial}{\\partial t} g(t, x, y)$" ], "text/plain": [ "Derivative(g(t, x, y), t)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g.dt" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We may also want to take a look at the stencil Devito will generate based on the chosen discretisation:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle - \\frac{g(t, x, y)}{dt} + \\frac{g(t + dt, x, y)}{dt}$" ], "text/plain": [ "-g(t, x, y)/dt + g(t + dt, x, y)/dt" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g.dt.evaluate" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "There also exist convenient shortcuts to express the forward and backward stencil points, `g(t+dt, x, y)` and `g(t-dt, x, y)`." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle g(t + dt, x, y)$" ], "text/plain": [ "g(t + dt, x, y)" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g.forward" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle g(t - dt, x, y)$" ], "text/plain": [ "g(t - dt, x, y)" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g.backward" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "And of course, there's nothing to stop us taking derivatives on these objects:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial}{\\partial t} g(t + dt, x, y)$" ], "text/plain": [ "Derivative(g(t + dt, x, y), t)" ] }, "execution_count": 12, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g.forward.dt" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial}{\\partial y} g(t + dt, x, y)$" ], "text/plain": [ "Derivative(g(t + dt, x, y), y)" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "g.forward.dy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# 45-Degree Rotated Finite Differences\n", "\n", "Rotated finite differences, when applied at a 45-degree angle, harness a unique isotropic discretization strategy for solving partial differential equations (PDEs) on a two-dimensional grid. This approach modifies the traditional finite difference stencil by rotating the coordinate system, specifically by 45 degrees, to better align with the problem's directional sensitivities. The mathematical transformations for this rotation are straightforward yet powerful, given by:\n", "\n", "$$x' = \\frac{x + y}{\\sqrt{2}}, \\quad y' = \\frac{y - x}{\\sqrt{2}}$$\n", "\n", "where $(x, y)$ and $(x', y')$ are the original and rotated coordinates, respectively.\n", "\n", "## Mathematical Definitions\n", "\n", "The partial derivatives in the rotated system become:\n", "\n", "$$\\frac{\\partial f}{\\partial x'} \\approx \\frac{f(x'+\\Delta x', y') - f(x'-\\Delta x', y')}{2\\Delta x'}$$\n", "$$\\frac{\\partial f}{\\partial y'} \\approx \\frac{f(x', y'+\\Delta y') - f(x', y'-\\Delta y')}{2\\Delta y'}$$\n", "\n", "Here, $\\Delta x'$ and $\\Delta y'$ represent the grid spacing in the rotated coordinates, which effectively equals the original grid spacing scaled by $\\sqrt{2}$.\n", "\n", "## Use Case and Advantages\n", "\n", "The 45-degree rotated finite difference method shines in scenarios where PDEs exhibit significant diagonal features or anisotropic behaviors. Traditional finite difference stencils, aligned with the Cartesian grid, can introduce numerical errors or fail to capture the essence of such phenomena accurately. By rotating the stencil, this method ensures a more symmetric and isotropic treatment of the grid points, leading to enhanced accuracy and stability in numerical simulations.\n", "\n", "### Advantages Include:\n", "\n", "- **Reduced Numerical Dispersion:** By capturing diagonal relationships more naturally, this method mitigates the dispersion errors commonly seen in conventional finite difference schemes.\n", "- **Enhanced Anisotropy Representation:** It offers a superior framework for simulating physical phenomena where directional dependencies are not aligned with the standard Cartesian axes.\n", "- **Improved Accuracy:** The isotropic discretization helps in achieving higher accuracy, especially for problems with inherent diagonal or anisotropic features.\n", "\n", "The 45-degree rotated finite difference method is a powerful tool for numerical analysts and engineers, providing a nuanced approach to solving complex PDEs with improved fidelity to the physical and geometric intricacies of the underlying problem.\n" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial}{\\partial x} f(x, y)$" ], "text/plain": [ "Derivative(f(x, y), x)" ] }, "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f.dx45" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\left(\\frac{f(x, y)}{2 h_{x}} - \\frac{f(x - h_x, y - h_y)}{2 h_{x}}\\right) + \\left(\\frac{f(x, y)}{2 h_{x}} - \\frac{f(x - h_x, y + h_y)}{2 h_{x}}\\right)$" ], "text/plain": [ "f(x, y)/(2*h_x) - f(x - h_x, y - h_y)/(2*h_x) + f(x, y)/(2*h_x) - f(x - h_x, y + h_y)/(2*h_x)" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "f.dx45.evaluate" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## A linear convection operator\n", "\n", "**Note:** The following example is derived from [step 5](http://nbviewer.ipython.org/github/barbagroup/CFDPython/blob/master/lessons/07_Step_5.ipynb) in the excellent tutorial series [CFD Python: 12 steps to Navier-Stokes](http://lorenabarba.com/blog/cfd-python-12-steps-to-navier-stokes/).\n", "\n", "In this simple example we will show how to derive a very simple convection operator from a high-level description of the governing equation. We will go through the process of deriving a discretised finite difference formulation of the state update for the field variable $u$, before creating a callable `Operator` object. Luckily, the automation provided by SymPy makes the derivation very nice and easy.\n", "\n", "The governing equation we want to implement is the linear convection equation:\n", "$$\\frac{\\partial u}{\\partial t}+c\\frac{\\partial u}{\\partial x} + c\\frac{\\partial u}{\\partial y} = 0.$$\n", "\n", "Before we begin, we must define some parameters including the grid, the number of timesteps and the timestep size. We will also initialize our velocity `u` with a smooth field:" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "tags": [ "nbval-ignore-output" ] }, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from examples.cfd import init_smooth, plot_field\n", "\n", "nt = 100 # Number of timesteps\n", "dt = 0.2 * 2. / 80 # Timestep size (sigma=0.2)\n", "c = 1 # Value for c\n", "\n", "# Then we create a grid and our function\n", "grid = Grid(shape=(81, 81), extent=(2., 2.))\n", "u = TimeFunction(name='u', grid=grid)\n", "\n", "# We can now set the initial condition and plot it\n", "init_smooth(field=u.data[0], dx=grid.spacing[0], dy=grid.spacing[1])\n", "init_smooth(field=u.data[1], dx=grid.spacing[0], dy=grid.spacing[1])\n", "\n", "plot_field(u.data[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Next, we wish to discretise our governing equation so that a functional `Operator` can be created from it. We begin by simply writing out the equation as a symbolic expression, while using shorthand expressions for the derivatives provided by the `Function` object. This will create a symbolic object of the dicretised equation.\n", "\n", "Using the Devito shorthand notation, we can express the governing equations as:" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial}{\\partial x} u(t, x, y) + \\frac{\\partial}{\\partial y} u(t, x, y) + \\frac{\\partial}{\\partial t} u(t, x, y) = 0$" ], "text/plain": [ "Eq(Derivative(u(t, x, y), x) + Derivative(u(t, x, y), y) + Derivative(u(t, x, y), t), 0)" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "eq = Eq(u.dt + c * u.dxl + c * u.dyl)\n", "eq" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We now need to rearrange our equation so that the term $u(t+dt, x, y)$ is on the left-hand side, since it represents the next point in time for our state variable $u$. Devito provides a utility called `solve`, built on top of SymPy's `solve`, to rearrange our equation so that it represents a valid state update for $u$. Here, we use `solve` to create a valid stencil for our update to `u(t+dt, x, y)`:" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle u(t + dt, x, y) = dt \\left(- \\frac{\\partial}{\\partial x} u(t, x, y) - \\frac{\\partial}{\\partial y} u(t, x, y) + \\frac{u(t, x, y)}{dt}\\right)$" ], "text/plain": [ "Eq(u(t + dt, x, y), dt*(-Derivative(u(t, x, y), x) - Derivative(u(t, x, y), y) + u(t, x, y)/dt))" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "stencil = solve(eq, u.forward)\n", "update = Eq(u.forward, stencil)\n", "update" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The right-hand side of the 'update' equation should be a stencil of the shape\n", "\n", "\n", "Once we have created this 'update' expression, we can create a Devito `Operator`. This `Operator` will basically behave like a Python function that we can call to apply the created stencil over our associated data, as long as we provide all necessary unknowns. In this case we need to provide the number of timesteps to compute via the keyword `time` and the timestep size via `dt` (both have been defined above):" ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "tags": [ "nbval-ignore-output" ] }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "Operator `Kernel` ran in 0.01 s\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "op = Operator(update, opt='noop')\n", "op(time=nt+1, dt=dt)\n", "\n", "plot_field(u.data[0])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Note that the real power of Devito is hidden within `Operator`, it will automatically generate and compile the optimized C code. We can look at this code (noting that this is not a requirement of executing it) via:" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "tags": [ "nbval-ignore-output" ] }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "#define _POSIX_C_SOURCE 200809L\n", "#define START(S) struct timeval start_ ## S , end_ ## S ; gettimeofday(&start_ ## S , NULL);\n", "#define STOP(S,T) gettimeofday(&end_ ## S, NULL); T->S += (double)(end_ ## S .tv_sec-start_ ## S.tv_sec)+(double)(end_ ## S .tv_usec-start_ ## S .tv_usec)/1000000;\n", "\n", "#include \"stdlib.h\"\n", "#include \"math.h\"\n", "#include \"sys/time.h\"\n", "#include \"omp.h\"\n", "\n", "struct dataobj\n", "{\n", " void *restrict data;\n", " unsigned long * size;\n", " unsigned long * npsize;\n", " unsigned long * dsize;\n", " int * hsize;\n", " int * hofs;\n", " int * oofs;\n", " void * dmap;\n", "} ;\n", "\n", "struct profiler\n", "{\n", " double section0;\n", "} ;\n", "\n", "\n", "int Kernel(struct dataobj *restrict u_vec, const float dt, const float h_x, const float h_y, const int time_M, const int time_m, const int x_M, const int x_m, const int y_M, const int y_m, const int nthreads, struct profiler * timers)\n", "{\n", " float (*restrict u)[u_vec->size[1]][u_vec->size[2]] __attribute__ ((aligned (64))) = (float (*)[u_vec->size[1]][u_vec->size[2]]) u_vec->data;\n", "\n", " for (int time = time_m, t0 = (time)%(2), t1 = (time + 1)%(2); time <= time_M; time += 1, t0 = (time)%(2), t1 = (time + 1)%(2))\n", " {\n", " START(section0)\n", " #pragma omp parallel num_threads(nthreads)\n", " {\n", " #pragma omp for collapse(2) schedule(dynamic,1)\n", " for (int x = x_m; x <= x_M; x += 1)\n", " {\n", " for (int y = y_m; y <= y_M; y += 1)\n", " {\n", " u[t1][x + 1][y + 1] = dt*(-(-u[t0][x][y + 1]/h_x + u[t0][x + 1][y + 1]/h_x) - (-u[t0][x + 1][y]/h_y + u[t0][x + 1][y + 1]/h_y) + u[t0][x + 1][y + 1]/dt);\n", " }\n", " }\n", " }\n", " STOP(section0,timers)\n", " }\n", "\n", " return 0;\n", "}\n", "\n" ] } ], "source": [ "print(op.ccode)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Second derivatives and high-order stencils\n", "\n", "In the above example only a combination of first derivatives was present in the governing equation. However, second (or higher) order derivatives are often present in scientific problems of interest, notably any PDE modeling diffusion. To generate second order derivatives we must give the `devito.Function` object another piece of information: the desired discretisation of the stencil(s).\n", "\n", "First, lets define a simple second derivative in `x`, for which we need to give $u$ a `space_order` of (at least) `2`. The shorthand for this second derivative is `u.dx2`. " ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y)$" ], "text/plain": [ "Derivative(u(t, x, y), (x, 2))" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u = TimeFunction(name='u', grid=grid, space_order=2)\n", "u.dx2" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle - \\frac{2.0 u(t, x, y)}{h_{x}^{2}} + \\frac{u(t, x - h_x, y)}{h_{x}^{2}} + \\frac{u(t, x + h_x, y)}{h_{x}^{2}}$" ], "text/plain": [ "-2.0*u(t, x, y)/h_x**2 + u(t, x - h_x, y)/h_x**2 + u(t, x + h_x, y)/h_x**2" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u.dx2.evaluate" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can increase the discretisation arbitrarily if we wish to specify higher order FD stencils:" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y)$" ], "text/plain": [ "Derivative(u(t, x, y), (x, 2))" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u = TimeFunction(name='u', grid=grid, space_order=4)\n", "u.dx2" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle - \\frac{2.5 u(t, x, y)}{h_{x}^{2}} - \\frac{0.0833333333 u(t, x - 2*h_x, y)}{h_{x}^{2}} + \\frac{1.33333333 u(t, x - h_x, y)}{h_{x}^{2}} + \\frac{1.33333333 u(t, x + h_x, y)}{h_{x}^{2}} - \\frac{0.0833333333 u(t, x + 2*h_x, y)}{h_{x}^{2}}$" ], "text/plain": [ "-2.5*u(t, x, y)/h_x**2 - 0.0833333333*u(t, x - 2*h_x, y)/h_x**2 + 1.33333333*u(t, x - h_x, y)/h_x**2 + 1.33333333*u(t, x + h_x, y)/h_x**2 - 0.0833333333*u(t, x + 2*h_x, y)/h_x**2" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u.dx2.evaluate" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "To implement the diffusion or wave equations, we must take the Laplacian $\\nabla^2 u$, which is the sum of the second derivatives in all spatial dimensions. For this, Devito also provides a shorthand expression, which means we do not have to hard-code the problem dimension (2D or 3D) in the code. To change the problem dimension we can create another `Grid` object and use this to re-define our `Function`'s:" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle u(t, x, y, z)$" ], "text/plain": [ "u(t, x, y, z)" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "grid_3d = Grid(shape=(5, 6, 7), extent=(1., 1., 1.))\n", "\n", "u = TimeFunction(name='u', grid=grid_3d, space_order=2)\n", "u" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can re-define our function `u` with a different `space_order` argument to change the discretisation order of the stencil expression created. For example, we can derive an expression of the 12th-order Laplacian $\\nabla^2 u$:" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y, z) + \\frac{\\partial^{2}}{\\partial y^{2}} u(t, x, y, z) + \\frac{\\partial^{2}}{\\partial z^{2}} u(t, x, y, z)$" ], "text/plain": [ "Derivative(u(t, x, y, z), (x, 2)) + Derivative(u(t, x, y, z), (y, 2)) + Derivative(u(t, x, y, z), (z, 2))" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u = TimeFunction(name='u', grid=grid_3d, space_order=12)\n", "u.laplace" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The same expression could also have been generated explicitly via:" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y, z) + \\frac{\\partial^{2}}{\\partial y^{2}} u(t, x, y, z) + \\frac{\\partial^{2}}{\\partial z^{2}} u(t, x, y, z)$" ], "text/plain": [ "Derivative(u(t, x, y, z), (x, 2)) + Derivative(u(t, x, y, z), (y, 2)) + Derivative(u(t, x, y, z), (z, 2))" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u.dx2 + u.dy2 + u.dz2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Derivatives of composite expressions\n", "\n", "Derivatives of any arbitrary expression can easily be generated:" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [], "source": [ "u = TimeFunction(name='u', grid=grid, space_order=2)\n", "v = TimeFunction(name='v', grid=grid, space_order=2, time_order=2)" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y) + \\frac{\\partial^{2}}{\\partial y^{2}} u(t, x, y) + \\frac{\\partial^{2}}{\\partial t^{2}} v(t, x, y)$" ], "text/plain": [ "Derivative(u(t, x, y), (x, 2)) + Derivative(u(t, x, y), (y, 2)) + Derivative(v(t, x, y), (t, 2))" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "v.dt2 + u.laplace" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle \\frac{\\partial^{2}}{\\partial x^{2}} \\left(\\frac{\\partial^{2}}{\\partial x^{2}} u(t, x, y) + \\frac{\\partial^{2}}{\\partial y^{2}} u(t, x, y) + \\frac{\\partial^{2}}{\\partial t^{2}} v(t, x, y)\\right)$" ], "text/plain": [ "Derivative(Derivative(u(t, x, y), (x, 2)) + Derivative(u(t, x, y), (y, 2)) + Derivative(v(t, x, y), (t, 2)), (x, 2))" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(v.dt2 + u.laplace).dx2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Which can, depending on the chosen discretisation, lead to fairly complex stencils: " ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/latex": [ "$\\displaystyle - \\frac{2.0 \\left(\\left(- \\frac{2.0 v(t, x, y)}{dt^{2}} + \\frac{v(t - dt, x, y)}{dt^{2}} + \\frac{v(t + dt, x, y)}{dt^{2}}\\right) + \\left(- \\frac{2.0 u(t, x, y)}{h_{x}^{2}} + \\frac{u(t, x - h_x, y)}{h_{x}^{2}} + \\frac{u(t, x + h_x, y)}{h_{x}^{2}}\\right) + \\left(- \\frac{2.0 u(t, x, y)}{h_{y}^{2}} + \\frac{u(t, x, y - h_y)}{h_{y}^{2}} + \\frac{u(t, x, y + h_y)}{h_{y}^{2}}\\right)\\right)}{h_{x}^{2}} + \\frac{\\left(- \\frac{2.0 v(t, x - h_x, y)}{dt^{2}} + \\frac{v(t - dt, x - h_x, y)}{dt^{2}} + \\frac{v(t + dt, x - h_x, y)}{dt^{2}}\\right) + \\left(\\frac{u(t, x, y)}{h_{x}^{2}} + \\frac{u(t, x - 2*h_x, y)}{h_{x}^{2}} - \\frac{2.0 u(t, x - h_x, y)}{h_{x}^{2}}\\right) + \\left(- \\frac{2.0 u(t, x - h_x, y)}{h_{y}^{2}} + \\frac{u(t, x - h_x, y - h_y)}{h_{y}^{2}} + \\frac{u(t, x - h_x, y + h_y)}{h_{y}^{2}}\\right)}{h_{x}^{2}} + \\frac{\\left(- \\frac{2.0 v(t, x + h_x, y)}{dt^{2}} + \\frac{v(t - dt, x + h_x, y)}{dt^{2}} + \\frac{v(t + dt, x + h_x, y)}{dt^{2}}\\right) + \\left(\\frac{u(t, x, y)}{h_{x}^{2}} - \\frac{2.0 u(t, x + h_x, y)}{h_{x}^{2}} + \\frac{u(t, x + 2*h_x, y)}{h_{x}^{2}}\\right) + \\left(- \\frac{2.0 u(t, x + h_x, y)}{h_{y}^{2}} + \\frac{u(t, x + h_x, y - h_y)}{h_{y}^{2}} + \\frac{u(t, x + h_x, y + h_y)}{h_{y}^{2}}\\right)}{h_{x}^{2}}$" ], "text/plain": [ "-2.0*(-2.0*v(t, x, y)/dt**2 + v(t - dt, x, y)/dt**2 + v(t + dt, x, y)/dt**2 - 2.0*u(t, x, y)/h_x**2 + u(t, x - h_x, y)/h_x**2 + u(t, x + h_x, y)/h_x**2 - 2.0*u(t, x, y)/h_y**2 + u(t, x, y - h_y)/h_y**2 + u(t, x, y + h_y)/h_y**2)/h_x**2 + (-2.0*v(t, x - h_x, y)/dt**2 + v(t - dt, x - h_x, y)/dt**2 + v(t + dt, x - h_x, y)/dt**2 + u(t, x, y)/h_x**2 + u(t, x - 2*h_x, y)/h_x**2 - 2.0*u(t, x - h_x, y)/h_x**2 - 2.0*u(t, x - h_x, y)/h_y**2 + u(t, x - h_x, y - h_y)/h_y**2 + u(t, x - h_x, y + h_y)/h_y**2)/h_x**2 + (-2.0*v(t, x + h_x, y)/dt**2 + v(t - dt, x + h_x, y)/dt**2 + v(t + dt, x + h_x, y)/dt**2 + u(t, x, y)/h_x**2 - 2.0*u(t, x + h_x, y)/h_x**2 + u(t, x + 2*h_x, y)/h_x**2 - 2.0*u(t, x + h_x, y)/h_y**2 + u(t, x + h_x, y - h_y)/h_y**2 + u(t, x + h_x, y + h_y)/h_y**2)/h_x**2" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(v.dt2 + u.laplace).dx2.evaluate" ] } ], "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.7" }, "widgets": { "state": {}, "version": "1.1.2" } }, "nbformat": 4, "nbformat_minor": 4 }