From 974611f4394b08d67c130196cfc35fddea1fee2a Mon Sep 17 00:00:00 2001 From: George Bisbas Date: Wed, 19 Feb 2025 14:52:25 +0200 Subject: [PATCH 01/12] examples: Refresh 08_snapshotting --- .../seismic/tutorials/08_snapshotting.ipynb | 186 ++++++++++++++---- 1 file changed, 148 insertions(+), 38 deletions(-) diff --git a/examples/seismic/tutorials/08_snapshotting.ipynb b/examples/seismic/tutorials/08_snapshotting.ipynb index 080e054b1c..8b20a9872c 100644 --- a/examples/seismic/tutorials/08_snapshotting.ipynb +++ b/examples/seismic/tutorials/08_snapshotting.ipynb @@ -6,9 +6,9 @@ "source": [ "# 08 - Snapshotting with Devito using the `ConditionalDimension`\n", "\n", - "This notebook intends to introduce new Devito users (especially with a C or FORTRAN background) to the best practice on saving snapshots to disk, as a binary float file. \n", + "This notebook intends to introduce new Devito users (especially with a C or FORTRAN background) to the best practice on saving snapshots to disk, as a binary float file.\n", "\n", - "We start by presenting a naive approach, and then introduce a more efficient method, which exploits Devito's `ConditionalDimension`." + "We start by presenting a naive (Python-level) approach and then introduce a more efficient method, which exploits Devito's `ConditionalDimension`." ] }, { @@ -69,6 +69,7 @@ ] }, { +<<<<<<< HEAD "data": { "text/plain": [ "PerformanceSummary([(PerfKey(name='section0', rank=None),\n", @@ -82,20 +83,36 @@ "execution_count": 2, "metadata": {}, "output_type": "execute_result" +======= + "name": "stdout", + "output_type": "stream", + "text": [ + "206\n" + ] +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) } ], "source": [ "# This cell sets up the problem that is already explained in the first TLE tutorial.\n", "\n", +<<<<<<< HEAD "# NBVAL_IGNORE_OUTPUT\n", "# %%flake8\n", "from examples.seismic import Receiver\n", "from examples.seismic import RickerSource\n", "from examples.seismic import Model, plot_velocity, TimeAxis\n", +======= + "#NBVAL_IGNORE_OUTPUT\n", + "#%%flake8\n", +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "from devito import TimeFunction\n", "from devito import Eq, solve\n", "from devito import Operator\n", "\n", + "from examples.seismic import Receiver\n", + "from examples.seismic import RickerSource\n", + "from examples.seismic import Model, plot_velocity, TimeAxis\n", + "\n", "\n", "# Set velocity model\n", "nx = 201\n", @@ -111,7 +128,7 @@ "model = Model(vp=v, origin=origin, shape=shape, spacing=spacing,\n", " space_order=2, nbl=10, bcs=\"damp\")\n", "\n", - "# Set time range, source, source coordinates and receiver coordinates\n", + "# Set time range, source, source and receiver coordinates\n", "t0 = 0. # Simulation starts a t=0\n", "tn = 1000. # Simulation lasts tn milliseconds\n", "dt = model.critical_dt # Time step from model grid spacing\n", @@ -141,9 +158,14 @@ "plot_velocity(model, source=src.coordinates.data,\n", " receiver=rec.coordinates.data[::4, :])\n", "\n", +<<<<<<< HEAD "# Used for reshaping\n", "vnx = nx+20\n", "vnz = nz+20\n", +======= + "# Get the model's grid shape for reshaping\n", + "vnx, vnz = model.grid.shape\n", +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "\n", "# Set symbolics for the wavefield object `u`, setting save on all time steps\n", "# (which can occupy a lot of memory), to later collect snapshots (naive method):\n", @@ -151,7 +173,7 @@ "u = TimeFunction(name=\"u\", grid=model.grid, time_order=2,\n", " space_order=2, save=time_range.num)\n", "\n", - "# Set symbolics of the operator, source and receivers:\n", + "# Set symbolics of the operator, source, and receivers:\n", "pde = model.m * u.dt2 - u.laplace + model.damp * u.dt\n", "stencil = Eq(u.forward, solve(pde, u.forward))\n", "src_term = src.inject(field=u.forward, expr=src * dt**2 / model.m)\n", @@ -159,7 +181,7 @@ "op = Operator([stencil] + src_term + rec_term, subs=model.spacing_map)\n", "\n", "# Run the operator for `(nt-2)` time steps:\n", - "op(time=nt-2, dt=model.critical_dt)\n" + "op(time=nt-2, dt=model.critical_dt)" ] }, { @@ -168,7 +190,7 @@ "source": [ "# Saving snaps to disk - naive approach\n", "\n", - "We want to get equally spaced snaps from the `nt-2` saved in `u.data`. The user can then define the total number of snaps `nsnaps`, which determines a `factor` to divide `nt`." + "We want to get equally spaced snaps from the `nt-2` steps saved in `u.data`. The user can then define the total number of snaps `nsnaps`, which determines a `factor` to divide `nt`." ] }, { @@ -180,10 +202,18 @@ "nsnaps = 100\n", "factor = round(u.shape[0] / nsnaps) # Get approx nsnaps, for any nt\n", "ucopy = u.data.copy(order='C')\n", +<<<<<<< HEAD "filename = \"naivsnaps.bin\"\n", "with open(filename, 'wb') as fh:\n", " for it in range(0, nsnaps):\n", " fh.write(ucopy[it*factor, :, :])" +======= + "filename = \"naivesnaps.bin\"\n", + "file_u = open(filename, 'wb')\n", + "for it in range(0, nsnaps):\n", + " file_u.write(ucopy[it*factor, :, :])\n", + "file_u.close()" +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) ] }, { @@ -213,13 +243,17 @@ "# NBVAL_IGNORE_OUTPUT\n", "plt.rcParams['figure.figsize'] = (20, 20) # Increases figure size\n", "\n", +<<<<<<< HEAD "imcnt = 1 # Image counter for plotting\n", "plot_num = 5 # Number of images to plot\n", +======= + "plot_num = 5 # Number of images to plot\n", + "indices = np.linspace(0, nsnaps-1, plot_num, dtype=int) # Indices for snapshots\n", +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "\n", - "for i in range(0, nsnaps, int(nsnaps/plot_num)):\n", - " plt.subplot(1, plot_num+1, imcnt+1)\n", - " imcnt = imcnt + 1\n", - " plt.imshow(np.transpose(u.data[i * factor, :, :]), vmin=-1, vmax=1, cmap=\"seismic\")\n", + "for i, ind in enumerate(indices):\n", + " plt.subplot(1, plot_num, i + 1)\n", + " plt.imshow(np.transpose(u.data[ind * factor, :, :]), vmin=-1, vmax=1, cmap=\"seismic\")\n", "\n", "plt.show()\n" ] @@ -248,13 +282,22 @@ } ], "source": [ +<<<<<<< HEAD "# NBVAL_IGNORE_OUTPUT\n", "with open(\"naivsnaps.bin\", \"rb\") as fh:\n", " snaps = np.fromfile(fh, dtype=np.float32)\n", " snaps = np.reshape(snaps, (nsnaps, vnx, vnz)) # reshape vec2mtx, devito format. nx first\n", +======= + "#NBVAL_IGNORE_OUTPUT\n", + "fobj = open(\"naivesnaps.bin\", \"rb\") \n", + "snaps = np.fromfile(fobj, dtype = np.float32) \n", + "snaps = np.reshape(snaps, (nsnaps, vnx, vnz)) #reshape vec2mtx, devito format. nx first\n", + "fobj.close()\n", +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "\n", "plt.rcParams['figure.figsize'] = (20, 20) # Increases figure size\n", "\n", +<<<<<<< HEAD "imcnt = 1 # Image counter for plotting\n", "plot_num = 5 # Number of images to plot\n", "\n", @@ -262,6 +305,14 @@ " plt.subplot(1, plot_num+1, imcnt+1)\n", " imcnt = imcnt + 1\n", " plt.imshow(np.transpose(snaps[i, :, :]), vmin=-1, vmax=1, cmap=\"seismic\")\n", +======= + "plot_num = 5 # Number of images to plot\n", + "indices = np.linspace(0, nsnaps-1, plot_num, dtype=int) # Indices for snapshots\n", + "\n", + "for i, ind in enumerate(indices):\n", + " plt.subplot(1, plot_num, i + 1)\n", + " plt.imshow(np.transpose(snaps[ind, :, :]), vmin=-1, vmax=1, cmap=\"seismic\")\n", +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "\n", "plt.show()" ] @@ -270,7 +321,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This C/FORTRAN way of saving snaps is clearly not optimal when using Devito; the wavefield object `u` is specified to save all snaps, and a memory copy is done at every `op` time step. Giving that we don't want all the snaps saved, this process is wasteful; only the selected snapshots should be copied during execution. \n", + "Note: This C/FORTRAN way of saving snaps is clearly not optimal when using Devito; the wavefield object `u` is specified to save all snaps, and a memory copy is done at every `op` time step. Giving that we don't want all the snaps saved, this process is wasteful; only the selected snapshots should be copied during execution. \n", "\n", "\n", "To address these issues, a better way to save snaps using Devito's capabilities is presented in the following section." @@ -295,14 +346,14 @@ "name": "stdout", "output_type": "stream", "text": [ - "factor is 2\n", - "t_sub\n" + "factor is 2\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ +<<<<<<< HEAD "Operator `Kernel` ran in 0.01 s\n" ] }, @@ -310,6 +361,9 @@ "name": "stderr", "output_type": "stream", "text": [ +======= + "Operator `Kernel` ran in 0.01 s\n", +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "Operator `Kernel` ran in 0.01 s\n" ] }, @@ -326,7 +380,7 @@ "# NBVAL_IGNORE_OUTPUT\n", "from devito import ConditionalDimension\n", "\n", - "nsnaps = 103 # desired number of equally spaced snaps\n", + "nsnaps = 103 # desired number of equally spaced snaps\n", "factor = round(nt / nsnaps) # subsequent calculated factor\n", "\n", "print(f\"factor is {factor}\")\n", @@ -336,7 +390,6 @@ " 't_sub', parent=model.grid.time_dim, factor=factor)\n", "usave = TimeFunction(name='usave', grid=model.grid, time_order=2, space_order=2,\n", " save=nsnaps, time_dim=time_subsampled)\n", - "print(time_subsampled)\n", "#####################\n", "\n", "u = TimeFunction(name=\"u\", grid=model.grid, time_order=2, space_order=2)\n", @@ -360,8 +413,13 @@ "\n", "# Part 3 #############\n", "print(\"Saving snaps file\")\n", +<<<<<<< HEAD "print(f\"Dimensions: nz = {nz + 2 * nb:d}, nx = {nx + 2 * nb:d}\")\n", "filename = \"snaps2.bin\"\n", +======= + "print(f\"Dimensions: nz = {vnz}, nx = {vnx}\")\n", + "filename = \"devito_snaps.bin\"\n", +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "usave.data.tofile(filename)\n", "#####################" ] @@ -390,6 +448,7 @@ } ], "source": [ +<<<<<<< HEAD "# NBVAL_IGNORE_OUTPUT\n", "with open(\"snaps2.bin\", \"rb\") as fh:\n", " snaps = np.fromfile(fh, dtype=np.float32)\n", @@ -403,6 +462,21 @@ " plt.subplot(1, plot_num, i+1)\n", " imcnt = imcnt + 1\n", " ind = i * int(nsnaps/plot_num)\n", +======= + "#NBVAL_IGNORE_OUTPUT\n", + "fobj = open(\"devito_snaps.bin\", \"rb\")\n", + "snaps = np.fromfile(fobj, dtype=np.float32)\n", + "snaps = np.reshape(snaps, (nsnaps, vnx, vnz))\n", + "fobj.close()\n", + "\n", + "plt.rcParams['figure.figsize'] = (20, 20) # Increases figure size\n", + "\n", + "plot_num = 5 # Number of images to plot\n", + "indices = np.linspace(0, nsnaps-1, plot_num, dtype=int) # Indices for snapshots\n", + "\n", + "for i, ind in enumerate(indices):\n", + " plt.subplot(1, plot_num, i + 1)\n", +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) " plt.imshow(np.transpose(snaps[ind, :, :]), vmin=-1, vmax=1, cmap=\"seismic\")\n", "\n", "plt.show()" @@ -418,28 +492,33 @@ "\n", "Further insight on how `ConditionalDimension` works and its most common uses can be found in [the Devito documentation](https://www.devitoproject.org/devito/dimension.html#devito.types.dimension.ConditionalDimension). The following excerpt exemplifies subsampling of simple functions:\n", "\n", - " Among the other things, ConditionalDimensions are indicated to implement\n", - " Function subsampling. In the following example, an Operator evaluates the\n", - " Function ``g`` and saves its content into ``f`` every ``factor=4`` iterations.\n", - " \n", - " >>> from devito import Dimension, ConditionalDimension, Function, Eq, Operator\n", - " >>> size, factor = 16, 4\n", - " >>> i = Dimension(name='i')\n", - " >>> ci = ConditionalDimension(name='ci', parent=i, factor=factor)\n", - " >>> g = Function(name='g', shape=(size,), dimensions=(i,))\n", - " >>> f = Function(name='f', shape=(int(size/factor),), dimensions=(ci,))\n", - " >>> op = Operator([Eq(g, 1), Eq(f, g)])\n", + "Among the other things, ConditionalDimensions are indicated to implement\n", + "Function subsampling. In the following example, an Operator evaluates the\n", + "Function ``g`` and saves its content into ``f`` every ``factor=4`` iterations.\n", + "\n", + "```python\n", + "from devito import Dimension, ConditionalDimension, Function, Eq, Operator\n", + "size, factor = 16, 4\n", + "i = Dimension(name='i')\n", + "ci = ConditionalDimension(name='ci', parent=i, factor=factor)\n", + "g = Function(name='g', shape=(size,), dimensions=(i,))\n", + "f = Function(name='f', shape=(int(size/factor),), dimensions=(ci,))\n", + "op = Operator([Eq(g, 1), Eq(f, g)])\n", + "```\n", " \n", - " The Operator generates the following for-loop (pseudocode)\n", - " .. code-block:: C\n", - " for (int i = i_m; i <= i_M; i += 1) {\n", - " g[i] = 1;\n", - " if (i%4 == 0) {\n", - " f[i / 4] = g[i];\n", - " }\n", - " }\n", + "The Operator generates the following for-loop (pseudocode)\n", + "```c\n", + "for (int i = i_m; i <= i_M; i += 1) {\n", + " g[i] = 1;\n", + " if ((i)%(cif) == 0)\n", + " {\n", + " //cif holds the value of 4 (int(16/4)) in this example\n", + " f[i / cif] = g[i]; \n", + " }\n", + "}\n", + "```\n", "\n", - "From this excerpt we can see that the C code generated by `Operator` with the extra argument `Eq(f,g)` mainly corresponds to adding an `if` block on the optimized C-code, which saves the desired snapshots on `f`, from `g`, at the correct times. Following the same line of thought, in the following section the symbolic and C-generated code are compared, with and without snapshots.\n", + "From this excerpt, we can see that the C code generated by `Operator` with the extra argument `Eq(f,g)` mainly corresponds to adding an `if` block on the optimized C-code, which saves the desired snapshots on `f`, from `g`, at the correct subsampled times. Following the same line of thought, in the following section the symbolic and C-generated code are compared, with and without snapshots.\n", "\n", "# About Part 2\n", " \n", @@ -3325,7 +3404,9 @@ "AAAAAAAAAAAALWlsc3QAAAAlqXRvbwAAAB1kYXRhAAAAAQAAAABMYXZmNTguNzYuMTAw\n", "\">\n", " Your browser does not support the video tag.\n", - "" + "\">\n", + " \n", + "\n" ], "text/plain": [ "" @@ -3359,16 +3440,38 @@ "plt.title('Modelling one shot over a 2-layer velocity model with Devito.')\n", "\n", "\n", + "# Add a text annotation for the frame counter\n", + "frame_text = ax.text(0.02, 0.95, '', transform=ax.transAxes,\n", + " color='white', fontsize=16,\n", + " bbox=dict(facecolor='black', alpha=0.5))\n", + "\n", "def update(i):\n", " matrice.set_array(snapsObj[i, :, :].T)\n", - " return matrice,\n", + " frame_text.set_text(f'Snap: {i+1}/{nsnaps}')\n", + " return matrice, frame_text\n", "\n", "\n", "# Animation\n", "ani = animation.FuncAnimation(fig, update, frames=nsnaps, interval=50, blit=True)\n", "\n", "plt.close(ani._fig)\n", +<<<<<<< HEAD "HTML(ani.to_html5_video())" +======= + "\n", + "video = ani.to_html5_video()\n", + "\n", + "# Adjust the size of the HTML video element to fit notebook width\n", + "html = f\"\"\"\n", + "
\n", + " \n", + "
\n", + "\"\"\"\n", + "\n", + "HTML(html)\n" +>>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) ] }, { @@ -3377,8 +3480,15 @@ "source": [ "# References\n", "\n", - "Louboutin, M., Witte, P., Lange, M., Kukreja, N., Luporini, F., Gorman, G., & Herrmann, F. J. (2017). Full-waveform inversion, Part 1: Forward modeling. The Leading Edge, 36(12), 1033-1036." + "Louboutin, M., Witte, P., Lange, M., Kukreja, N., Luporini, F., Gorman, G., & Herrmann, F. J. (2017). Full-waveform inversion, Part 1: Forward modeling. The Leading Edge, 36(12), 1033-1036. [[Available Online]](https://library.seg.org/doi/full/10.1190/tle36121033.1)" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { From 757cf39ebe990e3722ba736724019d2fac25da91 Mon Sep 17 00:00:00 2001 From: George Bisbas Date: Wed, 19 Feb 2025 18:37:03 +0200 Subject: [PATCH 02/12] examples: Better parametrization and error messages --- .../seismic/tutorials/08_snapshotting.ipynb | 11571 +++++++++++++++- 1 file changed, 11545 insertions(+), 26 deletions(-) diff --git a/examples/seismic/tutorials/08_snapshotting.ipynb b/examples/seismic/tutorials/08_snapshotting.ipynb index 8b20a9872c..5b54f97cc8 100644 --- a/examples/seismic/tutorials/08_snapshotting.ipynb +++ b/examples/seismic/tutorials/08_snapshotting.ipynb @@ -53,7 +53,11 @@ }, { "data": { +<<<<<<< HEAD "image/png": "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", +======= + "image/png": "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", +>>>>>>> 4bc5610ad (examples: Better parametrization and error messages) "text/plain": [ "
" ] @@ -65,10 +69,11 @@ "name": "stderr", "output_type": "stream", "text": [ - "Operator `Kernel` ran in 0.01 s\n" + "Operator `Kernel` ran in 0.02 s\n" ] }, { +<<<<<<< HEAD <<<<<<< HEAD "data": { "text/plain": [ @@ -78,11 +83,22 @@ " PerfEntry(time=0.0003080000000000001, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n", " (PerfKey(name='section2', rank=None),\n", " PerfEntry(time=0.00036299999999999977, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[]))])" +======= + "data": { + "text/plain": [ + "PerformanceSummary([(PerfKey(name='section0', rank=None),\n", + " PerfEntry(time=0.01129899999999998, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n", + " (PerfKey(name='section1', rank=None),\n", + " PerfEntry(time=1.4000000000000003e-05, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[])),\n", + " (PerfKey(name='section2', rank=None),\n", + " PerfEntry(time=3.000000000000001e-05, gflopss=0.0, gpointss=0.0, oi=0.0, ops=0, itershapes=[]))])" +>>>>>>> 4bc5610ad (examples: Better parametrization and error messages) ] }, "execution_count": 2, "metadata": {}, "output_type": "execute_result" +<<<<<<< HEAD ======= "name": "stdout", "output_type": "stream", @@ -90,6 +106,8 @@ "206\n" ] >>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) +======= +>>>>>>> 4bc5610ad (examples: Better parametrization and error messages) } ], "source": [ @@ -126,7 +144,7 @@ "v[:, int(nx/2):] = 2.5\n", "\n", "model = Model(vp=v, origin=origin, shape=shape, spacing=spacing,\n", - " space_order=2, nbl=10, bcs=\"damp\")\n", + " space_order=8, nbl=10, bcs=\"damp\")\n", "\n", "# Set time range, source, source and receiver coordinates\n", "t0 = 0. # Simulation starts a t=0\n", @@ -145,18 +163,19 @@ "src.coordinates.data[0, :] = np.array(model.domain_size) * .5\n", "src.coordinates.data[0, -1] = 20. # Depth is 20m\n", "\n", + "nrecs = 11\n", "rec = Receiver(\n", " name='rec',\n", " grid=model.grid,\n", - " npoint=101,\n", + " npoint=nrecs,\n", " time_range=time_range) # new\n", - "rec.coordinates.data[:, 0] = np.linspace(0, model.domain_size[0], num=101)\n", + "rec.coordinates.data[:, 0] = np.linspace(0, model.domain_size[0], num=11)\n", "rec.coordinates.data[:, 1] = 20. # Depth is 20m\n", "depth = rec.coordinates.data[:, 1] # Depth is 20m\n", "\n", "\n", "plot_velocity(model, source=src.coordinates.data,\n", - " receiver=rec.coordinates.data[::4, :])\n", + " receiver=rec.coordinates.data)\n", "\n", <<<<<<< HEAD "# Used for reshaping\n", @@ -171,7 +190,7 @@ "# (which can occupy a lot of memory), to later collect snapshots (naive method):\n", "\n", "u = TimeFunction(name=\"u\", grid=model.grid, time_order=2,\n", - " space_order=2, save=time_range.num)\n", + " space_order=8, save=time_range.num)\n", "\n", "# Set symbolics of the operator, source, and receivers:\n", "pde = model.m * u.dt2 - u.laplace + model.damp * u.dt\n", @@ -180,8 +199,8 @@ "rec_term = rec.interpolate(expr=u)\n", "op = Operator([stencil] + src_term + rec_term, subs=model.spacing_map)\n", "\n", - "# Run the operator for `(nt-2)` time steps:\n", - "op(time=nt-2, dt=model.critical_dt)" + "# Run the operator for `time_range.num-2` time steps:\n", + "op(time=time_range.num-2, dt=model.critical_dt)" ] }, { @@ -199,8 +218,8 @@ "metadata": {}, "outputs": [], "source": [ - "nsnaps = 100\n", - "factor = round(u.shape[0] / nsnaps) # Get approx nsnaps, for any nt\n", + "nsnaps = 100 # Number of snaps to save\n", + "factor = round(nt / nsnaps) # Save every `factor` nsnaps, for any nt\n", "ucopy = u.data.copy(order='C')\n", <<<<<<< HEAD "filename = \"naivsnaps.bin\"\n", @@ -230,7 +249,11 @@ "outputs": [ { "data": { +<<<<<<< HEAD "image/png": "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", +======= + "image/png": "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", +>>>>>>> 4bc5610ad (examples: Better parametrization and error messages) "text/plain": [ "
" ] @@ -272,7 +295,11 @@ "outputs": [ { "data": { +<<<<<<< HEAD "image/png": "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", +======= + "image/png": "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", +>>>>>>> 4bc5610ad (examples: Better parametrization and error messages) "text/plain": [ "
" ] @@ -295,7 +322,11 @@ "fobj.close()\n", >>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "\n", +<<<<<<< HEAD "plt.rcParams['figure.figsize'] = (20, 20) # Increases figure size\n", +======= + "plt.rcParams['figure.figsize'] = (20, 20) # Increases figure size\n", +>>>>>>> 4bc5610ad (examples: Better parametrization and error messages) "\n", <<<<<<< HEAD "imcnt = 1 # Image counter for plotting\n", @@ -346,7 +377,7 @@ "name": "stdout", "output_type": "stream", "text": [ - "factor is 2\n" + "Total number of timesteps is 242, factor is 2,number of snaps requested is 100. Thus we save up to timestep 200.\n" ] }, { @@ -363,16 +394,19 @@ "text": [ ======= "Operator `Kernel` ran in 0.01 s\n", +<<<<<<< HEAD >>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "Operator `Kernel` ran in 0.01 s\n" +======= + "Operator `Kernel` ran in 0.02 s\n" +>>>>>>> 4bc5610ad (examples: Better parametrization and error messages) ] }, { "name": "stdout", "output_type": "stream", "text": [ - "Saving snaps file\n", - "Dimensions: nz = 221, nx = 221\n" + "Saving snaps file\n" ] } ], @@ -380,19 +414,21 @@ "# NBVAL_IGNORE_OUTPUT\n", "from devito import ConditionalDimension\n", "\n", - "nsnaps = 103 # desired number of equally spaced snaps\n", + "nsnaps = 100 # desired number of equally spaced snaps\n", "factor = round(nt / nsnaps) # subsequent calculated factor\n", "\n", - "print(f\"factor is {factor}\")\n", + "print(f\"Total number of timesteps is {nt}, factor is {factor},\"\n", + " f\"number of snaps requested is {nsnaps}. Thus we save up to timestep\"\n", + " f\" {factor*nsnaps}.\")\n", "\n", "# Part 1 #############\n", "time_subsampled = ConditionalDimension(\n", " 't_sub', parent=model.grid.time_dim, factor=factor)\n", - "usave = TimeFunction(name='usave', grid=model.grid, time_order=2, space_order=2,\n", + "usave = TimeFunction(name='usave', grid=model.grid, time_order=2, space_order=8,\n", " save=nsnaps, time_dim=time_subsampled)\n", "#####################\n", "\n", - "u = TimeFunction(name=\"u\", grid=model.grid, time_order=2, space_order=2)\n", + "u = TimeFunction(name=\"u\", grid=model.grid, time_order=2, space_order=8)\n", "pde = model.m * u.dt2 - u.laplace + model.damp * u.dt\n", "stencil = Eq(u.forward, solve(pde, u.forward))\n", "src_term = src.inject(\n", @@ -406,18 +442,24 @@ "op2 = Operator([stencil] + src_term + [Eq(usave, u)] + rec_term,\n", " subs=model.spacing_map) # operator with snapshots\n", "\n", - "op1(time=nt - 2, dt=model.critical_dt) # run only for comparison\n", + "# NOTE: usave can hold up to `nsnaps` time steps. However, if we run\n", + "# for more than `nsnaps` steps, we will attempt to write out of bounds.\n", + "# So, we run up to factor*nsnaps - 1 steps to avoid writing out of bounds\n", + "op1(time=factor*nsnaps - 1, dt=model.critical_dt) # run only for comparison\n", "u.data.fill(0.)\n", - "op2(time=nt - 2, dt=model.critical_dt)\n", + "op2(time=factor*nsnaps - 1, dt=model.critical_dt)\n", "#####################\n", "\n", "# Part 3 #############\n", "print(\"Saving snaps file\")\n", +<<<<<<< HEAD <<<<<<< HEAD "print(f\"Dimensions: nz = {nz + 2 * nb:d}, nx = {nx + 2 * nb:d}\")\n", "filename = \"snaps2.bin\"\n", ======= "print(f\"Dimensions: nz = {vnz}, nx = {vnx}\")\n", +======= +>>>>>>> 4bc5610ad (examples: Better parametrization and error messages) "filename = \"devito_snaps.bin\"\n", >>>>>>> 504aa89e0 (examples: Refresh 08_snapshotting) "usave.data.tofile(filename)\n", @@ -438,7 +480,11 @@ "outputs": [ { "data": { +<<<<<<< HEAD "image/png": "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", +======= + "image/png": "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", +>>>>>>> 4bc5610ad (examples: Better parametrization and error messages) "text/plain": [ "
" ] @@ -725,20 +771,33 @@ { "data": { "text/html": [ +<<<<<<< HEAD "