{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Forcing & Analysis -- 2D Turbulence" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Overview:** This notebook describes how to construct a forced 2D turbulence simulation and analyze the output.\n", "\n", "**About Dedalus:** [Dedalus](http://dedalus-project.org) is an open-source Python package for solving partial differential equations (PDEs) using global spectral methods.\n", "These methods provide highly accurate numerical solutions for PDEs with smooth solutions in simple domains like boxes and spheres.\n", "Dedalus implements modern parallel algorithms utilizing sparse polynomial bases, but all with an easy-to-use symbolic interface.\n", "The code is being used in a wide range of fields, often for problems involving fluid dynamics.\n", "\n", "**Author:** [Keaton Burns](http://keaton-burns.com)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Setup" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "This cell checks if Dedalus is installed and performs some other basic setup.\n", "\n", "If Dedalus is not installed and you are using Google Colab, it will automatically be installed.\n", "This may take a few minutes the first time you run the notebook, but subsequent sessions during the next day or so should have the installation cached.\n", "No need to worry about the details -- just execute the cell.\n", "\n", "If you are not using Google Colab, follow the installation instructions in the [Dedalus Docs](https://dedalus-project.readthedocs.io/en/latest/pages/installation.html) to install Dedalus locally on your computer.\n", "Installation using conda is typically straightforward for Mac and Linux.\n", "No promises on Windows.\n", "Execute the cell to confirm Dedalus is installed and importable." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "env: OMP_NUM_THREADS=1\n", "env: NUMEXPR_MAX_THREADS=1\n", "Dedalus already installed :)\n" ] } ], "source": [ "# Set environment variables for best performance\n", "%env OMP_NUM_THREADS=1\n", "%env NUMEXPR_MAX_THREADS=1\n", "\n", "# Minimize logging output\n", "import logging\n", "logging.disable(logging.DEBUG)\n", "\n", "# Check if running on google colab\n", "import os\n", "using_google_colab = bool(os.getenv(\"COLAB_RELEASE_TAG\"))\n", "\n", "# Check for Dedalus\n", "try:\n", " import dedalus.public as de\n", " print(\"Dedalus already installed :)\")\n", "except:\n", " print(\"Dedalus not installed yet.\")\n", " if using_google_colab:\n", " print(\"Installing for Google Colab.\")\n", " print()\n", " # Step 1: Install FFTW\n", " !apt-get install libfftw3-dev\n", " !apt-get install libfftw3-mpi-dev\n", " # Step 2: Set paths for Dedalus installation\n", " import os\n", " os.environ['MPI_INCLUDE_PATH'] = \"/usr/lib/x86_64-linux-gnu/openmpi/include\"\n", " os.environ['MPI_LIBRARY_PATH'] = \"/usr/lib/x86_64-linux-gnu\"\n", " os.environ['FFTW_INCLUDE_PATH'] = \"/usr/include\"\n", " os.environ['FFTW_LIBRARY_PATH'] = \"/usr/lib/x86_64-linux-gnu\"\n", " # Step 3: Install Dedalus using pip\n", " !pip3 install cython \"mpi4py<4.0\" numpy setuptools wheel\n", " !CC=mpicc pip3 install --no-cache --no-build-isolation http://github.com/dedalusproject/dedalus/zipball/master/\n", " !pip3 install -q ipympl\n", " # Step 4: Check installation\n", " print()\n", " try:\n", " import dedalus.public as de\n", " print(\"Dedalus successfully installed :)\")\n", " except:\n", " print(\"Error installing Dedalus :(\")\n", " raise\n", " else:\n", " print(\"See website for installation instructions:\")\n", " print(\"https://dedalus-project.readthedocs.io/en/latest/pages/installation.html\")\n", "\n", "# Setup interactive matplotlib\n", "if using_google_colab:\n", " from google.colab import output\n", " output.enable_custom_widget_manager()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# Content" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "First let's import everything we need to run the rest of the notebook." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "np.seterr(over=\"raise\")\n", "import matplotlib.pyplot as plt\n", "import dedalus.public as d3\n", "import logging\n", "logger = logging.getLogger(__name__)\n", "%matplotlib widget" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 1. Setup domain and fields" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We begin by setting up the domain for a forced 2D turbulence simulation.\n", "We'll take as our domain a doubly-periodic box of size $L = 2 \\pi$, discretized with $N$ Fourier modes in each dimension.\n", "\n", "We first create a Cartesian coordinate system, then a Distributor object, and finally RealFourier bases for each dimension.\n", "Since we'll be solving Navier-Stokes with quadratic nonlinearities, we'll pick the dealias factors to be 3/2." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Domain parameters\n", "L = 2 * np.pi\n", "N = 512\n", "mesh = None\n", "dtype = np.float64\n", "dealias = 3 / 2\n", "\n", "# Domain\n", "coords = d3.CartesianCoordinates('x', 'y')\n", "dist = d3.Distributor(coords, mesh=mesh, dtype=dtype)\n", "xbasis = d3.RealFourier(coords[0], N, bounds=(0, L), dealias=dealias)\n", "ybasis = d3.RealFourier(coords[1], N, bounds=(0, L), dealias=dealias)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Next we create the fields we'll need for the simulation.\n", "For incompressible 2D flow, we can use the streamfunction-vorticity formulation to simply the enforcement of incompressibility and speed up the computation.\n", "This requires us to define just the streamfunction $\\psi$ as the variable field we'll be solving for.\n", "We also create a constant field $c$ which will be used to set the gauge freedom in the streamfunction-vorticity formulation." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# Fields\n", "psi = dist.Field(name='psi', bases=(xbasis, ybasis))\n", "c = dist.Field(name='c')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We do not need to define other fields to represent the velocity or vorticity.\n", "These can be written entirely as symbolic expressions based on the streamfunction using the vector calculus operators in Dedalus, and used later to simplify the specification of equations and analysis tasks." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "# Substitutions\n", "u = -d3.skew(d3.grad(psi)) # velocity vector: [dy(psi), -dx(psi)]\n", "w = -d3.lap(psi) # vorticity: dx(uy) - dy(ux)\n", "e = (u@u) / 2 # energy density\n", "z = (w*w) / 2 # enstrophy density" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 2. Stochastic forcing" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "To get a statistically-steady turbulent state, we will use stochastic band-limited forcing with a prescribed energy injection rate.\n", "First we specify the energy injection rate, primary wavenumber, and bandwidth of the stochastic forcing.\n", "We then create a field called `Fw` whose values will be set to a new random forcing on every iteration, and define functions to do so.\n", "\n", "The precise normalizations of forcings like this are tricky to get right, but important for precisely controlling the rate of energy injection.\n", "Here we create a normalized Gaussian random field with support concentrated on a ring in Fourier space.\n", "We also create a function that scales this forcing according to the timestep, as required for a stochastic integrator, and sets the coefficients of the `Fw` field." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "# Forcing parameters\n", "epsilon = 1 # Energy injection rate\n", "kf = 50 # Forcing wavenumber\n", "kfw = 2 # Forcing bandwidth\n", "seed = None # Random seed\n", "\n", "# Derived parameters\n", "eta = epsilon * kf**2 # Enstrophy injection rate\n", "\n", "# Forcing field and derived parameters\n", "Fw = dist.Field(name='Fw', bases=(xbasis, ybasis))\n", "kx = xbasis.wavenumbers[dist.local_modes(xbasis)]\n", "ky = ybasis.wavenumbers[dist.local_modes(ybasis)]\n", "dkx = dky = 2 * np.pi / L\n", "\n", "# Forcing function\n", "rand = np.random.RandomState(seed)\n", "\n", "def draw_gaussian_random_field():\n", " \"\"\"Create Gaussian random field concentrating on a ring in Fourier space with unit variance.\"\"\"\n", " k = (kx**2 + ky**2)**0.5\n", " # 1D power spectrum: normalized Gaussian, no mean\n", " P1 = np.exp(-(k-kf)**2/2/kfw**2) / np.sqrt(kfw**2 * np.pi / 2) * (k != 0)\n", " # 2D power spectrum: divide by polar Jacobian\n", " P2 = P1 / 2 / np.pi / (k + (k==0))\n", " # 2D coefficient poewr spectrum: divide by mode power\n", " Pc = P2 / 2**((kx == 0).astype(float) + (ky == 0).astype(float) - 2)\n", " # Forcing amplitude, including division between sine and cosine\n", " f_amp = (Pc / 2 * dkx * dkx)**0.5\n", " # Forcing with random phase\n", " f = f_amp * rand.randn(*k.shape)\n", " return f\n", "\n", "def set_vorticity_forcing(timestep):\n", " \"\"\"Set vorticity forcing field from scaled Gaussian random field.\"\"\"\n", " # Set forcing to normalized Gaussian random field\n", " Fw['c'] = draw_gaussian_random_field()\n", " # Rescale by forcing rate, including factor for 1/2 in kinetic energy\n", " Fw['c'] *= (2 * eta / timestep)**0.5" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 3. Build problem and solver" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Next we can build the Problem and Solver objects for our simulation.\n", "Our PDE is 2D incompressible Navier-Stokes in the streamfunction-vorticity formulation.\n", "We will include large-scale drag as well, so the simulation can come into energy equilibrium:\n", "\n", "$$\\partial_t \\omega + \\vec{u} \\cdot \\nabla \\omega = - \\alpha \\omega + \\nu \\nabla^2 \\omega + F_\\omega$$\n", "$$\\omega = - \\nabla^2 \\psi$$\n", "\n", "Since we have symbolically defined $\\omega$ in terms of $\\psi$ via the Laplacian, we do not need this as an additional equation.\n", "However, in this formulation there is a gauge freedom in the mean value of the streamfunction.\n", "This gauge must be fixed to create a well-posed problem.\n", "This is achieved by adding our undetermined constant field $c$ to the vorticity equaion, effectively absorbing the mean mode of the vorticity equation which otherwise reads $0 = 0$.\n", "This gives us the freedom to add an additional constraint fixing the streamfunction gauge." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Problem parameters\n", "L_diss = L / N # Dissipation scale\n", "L_fric = L # Friction scale\n", "\n", "# Derived parameters\n", "nu = L_diss**2 * eta**(1/3) # Viscosity\n", "alpha = epsilon**(1/3) * L_fric**(-2/3) # Friction\n", "\n", "# Problem\n", "problem = d3.IVP([psi, c], namespace=locals())\n", "problem.add_equation(\"dt(w) - nu*lap(w) + alpha*w + c = -u@grad(w) + Fw\")\n", "problem.add_equation(\"integ(psi) = 0\");" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Running multidimensional simulations on a single core in a notebook is rather slow, so we'll just run this simulation for a very short time for illustrative purposes.\n", "The full script associated with this example is also available in the [online repository](https://github.com/kburns/cism_dedalus_2023), and this version can be easily ran at larger scale on a workstation or cluster." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2024-09-27 10:12:21,199 subsystems 0/1 INFO :: Building subproblem matrices 1/256 (~0%) Elapsed: 0s, Remaining: 7s, Rate: 3.5e+01/s\n", "2024-09-27 10:12:21,577 subsystems 0/1 INFO :: Building subproblem matrices 26/256 (~10%) Elapsed: 0s, Remaining: 4s, Rate: 6.4e+01/s\n", "2024-09-27 10:12:22,111 subsystems 0/1 INFO :: Building subproblem matrices 52/256 (~20%) Elapsed: 1s, Remaining: 4s, Rate: 5.5e+01/s\n", "2024-09-27 10:12:22,494 subsystems 0/1 INFO :: Building subproblem matrices 78/256 (~30%) Elapsed: 1s, Remaining: 3s, Rate: 5.9e+01/s\n", "2024-09-27 10:12:22,937 subsystems 0/1 INFO :: Building subproblem matrices 104/256 (~41%) Elapsed: 2s, Remaining: 3s, Rate: 5.9e+01/s\n", "2024-09-27 10:12:23,402 subsystems 0/1 INFO :: Building subproblem matrices 130/256 (~51%) Elapsed: 2s, Remaining: 2s, Rate: 5.8e+01/s\n", "2024-09-27 10:12:23,797 subsystems 0/1 INFO :: Building subproblem matrices 156/256 (~61%) Elapsed: 3s, Remaining: 2s, Rate: 5.9e+01/s\n", "2024-09-27 10:12:24,210 subsystems 0/1 INFO :: Building subproblem matrices 182/256 (~71%) Elapsed: 3s, Remaining: 1s, Rate: 6.0e+01/s\n", "2024-09-27 10:12:24,634 subsystems 0/1 INFO :: Building subproblem matrices 208/256 (~81%) Elapsed: 3s, Remaining: 1s, Rate: 6.0e+01/s\n", "2024-09-27 10:12:25,027 subsystems 0/1 INFO :: Building subproblem matrices 234/256 (~91%) Elapsed: 4s, Remaining: 0s, Rate: 6.1e+01/s\n", "2024-09-27 10:12:25,357 subsystems 0/1 INFO :: Building subproblem matrices 256/256 (~100%) Elapsed: 4s, Remaining: 0s, Rate: 6.1e+01/s\n" ] } ], "source": [ "# Solver parameters\n", "timestepper = d3.RK222\n", "stop_sim_time = 0.2\n", "\n", "# Solver\n", "solver = problem.build_solver(timestepper)\n", "solver.stop_sim_time = stop_sim_time" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 4. Analysis tasks" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "To simplify saving simulation data, Dedalus includes a framework for evaluating and saving arbitrary analysis tasks while an initial value problem is running.\n", "These analysis tasks can be specified symbolically and are saved to HDF5 files.\n", "\n", "**Analysis handlers**\n", "\n", "The explicit evaluation of analysis tasks during timestepping is controlled by the `solver.evaluator` object.\n", "Various handler objects can be attached to the evaluator, and control when the evaluator computes their own set of tasks and what happens to the resulting data.\n", "For simulation analysis, the most useful handler is the `FileHandler`, which regularly computes tasks and writes the data to HDF5 files. \n", "\n", "When setting up a file handler, you specify the name/path for the output directory/files, as well as the cadence at which you want the handler's tasks to be evaluated.\n", "This cadence can be in terms of any combination of:\n", "* simulation time, specified with `sim_dt`,\n", "* wall time, specified with `wall_dt`\n", "* iteration number, specified with `iter`\n", "\n", "To limit file sizes, the output from a file handler is split up into different \"sets\" over time, each containing some number of writes that can be limited with the `max_writes` keyword when the file handler is constructed.\n", "You can add an arbitrary number of file handlers to save different sets of tasks at different cadences and to different files.\n", "\n", "**Analysis tasks**\n", "\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "Analysis tasks are added to a given handler using the `add_task` method. \n", "Tasks are entered as operator expressions or in plain text and parsed using the same namespace that is used for equation entry. \n", "For each task, you can additionally specify the output layout, scaling factors, and a referece name.\n", "\n", "Let's create two different handlers, one for saving simulation snapshots, and one for saving scalar summary statistics at a higher cadence:" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# Analysis parameters\n", "snapshots_dt = 0.1\n", "scalars_dt = 0.01\n", "\n", "# Analysis\n", "snapshots = solver.evaluator.add_file_handler('snapshots', sim_dt=snapshots_dt, max_writes=1, mode='overwrite')\n", "snapshots.add_task(psi, name='psi')\n", "snapshots.add_task(w, name='vorticity')\n", "\n", "scalars = solver.evaluator.add_file_handler('scalars', sim_dt=scalars_dt, mode='overwrite')\n", "ave = d3.Average\n", "scalars.add_task(ave(e), name='E')\n", "scalars.add_task(ave(z), name='Z')\n", "scalars.add_task(ave(-alpha * 2 * e), name='E friction')\n", "scalars.add_task(ave(-alpha * 2 * z), name='Z friction')\n", "scalars.add_task(ave(nu * u @ d3.lap(u)), name='E viscosity')\n", "scalars.add_task(ave(nu * w * d3.lap(w)), name='Z viscosity')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 5. Adaptive timestepping and main loop" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "For more complex simulations, a constant timestep may be too restrictive, and we may want to choose the timestep adaptively based on a CFL criterion.\n", "The Dedalus `CFL` tool allows you to do this, and has a number of optional parameters to prevent unneccesary timestep changes (which can be computationally costly) and to keep the timestep within reasonable bounds.\n", "\n", "Here's an example of setting up a CFL criterion based on an estimate of the RMS velocity we expect, and some typical parameters choices for the CFL options:" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "# Timestepping parameters\n", "dx = L / N # Grid spacing\n", "U = epsilon**(1/3) * L_fric**(1/3) # Friction velocity\n", "safety = 0.5 # CFL safety factor\n", "max_dt = safety * dx / U # Timestep\n", "\n", "# CFL\n", "CFL = d3.CFL(solver, initial_dt=max_dt, cadence=10, safety=safety, max_change=1.5, min_change=0.5, max_dt=max_dt, threshold=0.05)\n", "CFL.add_velocity(u)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "We can now run the simulation just as in the previous tutorial, but without needing to manually save any data during the main loop. \n", "The evaluator will automatically compute and save the specified analysis tasks at the proper cadence as the simulation is advanced.\n", "First, we compute the new timestep every iteration using the `CFL.compute_timestep` method.\n", "We then set new random forcing and take a step forward using this timestep.\n", "At the end of the simulation, we can print some common run statistics with `solver.log_stats()`." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2024-09-27 10:12:26,025 __main__ 0/1 INFO :: Starting loop\n", "2024-09-27 10:12:29,127 __main__ 0/1 INFO :: Iteration=1, Time=3.325217e-03, dt=3.325217e-03\n", "2024-09-27 10:12:31,220 __main__ 0/1 INFO :: Iteration=11, Time=3.657738e-02, dt=3.325217e-03\n", "2024-09-27 10:12:32,845 __main__ 0/1 INFO :: Iteration=21, Time=6.982955e-02, dt=3.325217e-03\n", "2024-09-27 10:12:34,566 __main__ 0/1 INFO :: Iteration=31, Time=1.030817e-01, dt=3.325217e-03\n", "2024-09-27 10:12:36,172 __main__ 0/1 INFO :: Iteration=41, Time=1.363339e-01, dt=3.325217e-03\n", "2024-09-27 10:12:37,804 __main__ 0/1 INFO :: Iteration=51, Time=1.695861e-01, dt=3.325217e-03\n", "2024-09-27 10:12:39,714 __main__ 0/1 INFO :: Iteration=61, Time=2.028382e-01, dt=3.325217e-03\n", "2024-09-27 10:12:39,716 solvers 0/1 INFO :: Simulation stop time reached.\n", "2024-09-27 10:12:39,716 solvers 0/1 INFO :: Final iteration: 61\n", "2024-09-27 10:12:39,717 solvers 0/1 INFO :: Final sim time: 0.2028382199317209\n", "2024-09-27 10:12:39,717 solvers 0/1 INFO :: Setup time (init - iter 0): 7.195 sec\n", "2024-09-27 10:12:39,718 solvers 0/1 INFO :: Warmup time (iter 0-10): 3.444 sec\n", "2024-09-27 10:12:39,719 solvers 0/1 INFO :: Run time (iter 10-end): 8.641 sec\n", "2024-09-27 10:12:39,719 solvers 0/1 INFO :: CPU time (iter 10-end): 0.0024 cpu-hr\n", "2024-09-27 10:12:39,719 solvers 0/1 INFO :: Speed: 3.082e+06 mode-stages/cpu-sec\n" ] } ], "source": [ "# Main loop\n", "try:\n", " logger.info('Starting loop')\n", " while solver.proceed:\n", " timestep = CFL.compute_timestep()\n", " set_vorticity_forcing(timestep)\n", " solver.step(timestep)\n", " if (solver.iteration-1) % 10 == 0:\n", " logger.info('Iteration=%i, Time=%e, dt=%e' %(solver.iteration, solver.sim_time, timestep))\n", "except:\n", " logger.error('Exception raised, triggering end of main loop.')\n", " raise\n", "finally:\n", " solver.log_stats()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 6. Post-processing" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "By default, the output files for each file handler are arranged as follows:\n", "\n", "1. A base folder taking the name that was specified when the file handler was constructed, e.g. `scalars/`.\n", "2. Within the base folder are HDF5 files for each output set, with the same name plus a set number, e.g. `scalars_s1.h5`.\n", "\n", "Each HDF5 file contains a \"tasks\" group containing a dataset for each task assigned to the file handler. \n", "The first dimension of the dataset is time, the subsequent dimensions are the vector/tensor components of the task (if applicable), and finally the spatial dimensions of the task.\n", "\n", "The HDF5 datasets are self-describing, with dimensional scales attached to each axis. \n", "For the first axis, these include the simulation time, wall time, iteration, and write number. \n", "For the spatial axes, the scales correspond to grid points or modes, based on the task layout.\n", "\n", "Let's open up the first scalars set file and plot a time series of the average kinetic energy and enstrophy:" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "6a179a2e5e6d440aa12551fe920533fc", "version_major": 2, "version_minor": 0 }, "image/png": "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", "text/html": [ "\n", "