diff --git a/diffphys-code-ns-v2.ipynb b/diffphys-code-ns-v2.ipynb new file mode 100644 index 0000000..65cf765 --- /dev/null +++ b/diffphys-code-ns-v2.ipynb @@ -0,0 +1,520 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "o4JZ84moBKMr" + }, + "source": [ + "# Differentiable Fluid Simulations\n", + "\n", + "Next, we'll target a more complex example with the Navier-Stokes equations as model. We'll target a 2D case with velocity $\\mathbf{u}$, no explicit viscosity term, and a marker density $d$ that drives a simple Boussinesq buoyancy term $\\eta d$ adding a force along the y dimension:\n", + "\n", + "$\\begin{aligned}\n", + " \\frac{\\partial u_x}{\\partial{t}} + \\mathbf{u} \\cdot \\nabla u_x &= - \\frac{1}{\\rho} \\nabla p \n", + " \\\\\n", + " \\frac{\\partial u_y}{\\partial{t}} + \\mathbf{u} \\cdot \\nabla u_y &= - \\frac{1}{\\rho} \\nabla p + \\eta d\n", + " \\\\\n", + " \\text{s.t.} \\quad \\nabla \\cdot \\mathbf{u} &= 0,\n", + " \\\\\n", + " \\frac{\\partial d}{\\partial{t}} + \\mathbf{u} \\cdot \\nabla d &= 0 \n", + "\\end{aligned}$\n", + "\n", + "As optimization objective we'll consider a more difficult variant of the previous example: the state of the observed density $d$ should match a given target after $n=20$ steps of simulation. In contrast to before, the marker $d$ cannot be modified in any way, but only the initial state of the velocity $\\mathbf{u}$ at $t=0$. This gives us a split between observable quantities for the loss formulation, and quantities that we can interact with during the optimization (or later on via NNs).\n", + "\n", + "First, let's get the loading of python modules out of the way:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "da1uZcDXdVcF" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/thuerey/miniconda3/envs/tf/lib/python3.8/_collections_abc.py:743: MatplotlibDeprecationWarning: The global colormaps dictionary is no longer considered public API.\n", + " for key in self._mapping:\n", + "/Users/thuerey/miniconda3/envs/tf/lib/python3.8/_collections_abc.py:744: MatplotlibDeprecationWarning: The global colormaps dictionary is no longer considered public API.\n", + " yield (key, self._mapping[key])\n" + ] + } + ], + "source": [ + "#!pip install --upgrade --quiet phiflow\n", + "#!pip install --upgrade --quiet git+https://github.com/tum-pbs/PhiFlow@develop\n", + "from phi.flow import * # The Dash GUI is not supported on Google Colab, ignore the warning\n", + "import pylab" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BVV1IKVqDfLl" + }, + "source": [ + "## Setting up the simulation\n", + "\n", + "To make things a bit more interesting - and to move a bit closer to a NN training process - let's set up of four fluid simulations that run in parallel, i.e. a mini batch similar to DL training. \n", + "\n", + "While the simulation setup is very similar to before, we'll define an additional batch dimension in addition to the spatial dimensions `x` and `y`. Below, this additional dimension is triggered by inflow tensor, which contains an named `nbatch` dimension, in addition to the spatial ones (the name `batch` is alredy taken). The two `print` statements below illustrate this behavior: they print the tensor shapes with all dimensions, and next only the spatial ones.\n", + "\n", + "TODO xxx **In phiflow we can directly pass a `batch_size=4` parameter to the `Fluid` object. Each fluid simulation is fully independent. In this case they differ by having circular Inflows at different locations.**\n", + "TODO ,explain expansion!\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "id": "WrA3IXDxv31P" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Inflow shape: (nbatch=4, x=32, y=40)\n", + "Inflow shape, spatial only: (x=32, y=40)\n", + "Initial velocity shape: (x=32, y=40, vector=2) \n", + "\n", + "Velocity shape after 1 step: (nbatch=4, x=32, y=40, vector=2)\n" + ] + } + ], + "source": [ + "domain = Domain(x=32, y=40, boundaries=CLOSED, bounds=Box[0:32, 0:40])\n", + "\n", + "smoke = domain.scalar_grid(0) # sampled at cell centers\n", + "velocity = domain.staggered_grid(0) # sampled in staggered form at face centers \n", + "\n", + "sphere_centers = [(10,5), (12,5), (19,5), (16,5)]\n", + "inflow_location = math.tensor(sphere_centers, names='nbatch,vector')\n", + "#inflow_location = math.tensor([(4, 5), (8, 5), (12, 5), (16, 5)], names='inflow_loc,vector')\n", + "inflow = domain.grid(Sphere(center=inflow_location, radius=3)) * 0.6\n", + "\n", + "\n", + "#print(f\"DEBUG : {velocity.shape.nbatch}\")\n", + "\n", + "print(f\"Inflow shape: {inflow.shape}\")\n", + "print(f\"Inflow shape, spatial only: {inflow.shape.spatial}\")\n", + "print(f\"Initial velocity shape: {velocity.shape} \\n\")\n", + "\n", + "# world = World()\n", + "# fluid = world.add(Fluid(Domain([40, 32], boundaries=CLOSED), buoyancy_factor=0.05, batch_size=4), physics=IncompressibleFlow())\n", + "# centers = [[5,10], [5,12], [5,14], [5,16]]\n", + "# world.add(Inflow(Sphere(center=centers, radius=3), rate=0.2));\n", + " #world.step(dt=1.5)\n", + " #for _ in range(20):\n", + "\n", + "for frame in range(20):\n", + " smoke = advect.mac_cormack(smoke, velocity, dt=1) + inflow\n", + " buoyancy_force = smoke * (0, 0.5) >> velocity\n", + " velocity = advect.semi_lagrangian(velocity, velocity, dt=1) + buoyancy_force\n", + " velocity, _, _, _ = fluid.make_incompressible(velocity, domain)\n", + " if frame==0:\n", + " print(f\"Velocity shape after 1 step: {velocity.shape}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**TODO** explain nbatch\n", + "phiflow automatically expands dimensions...\n", + "\n", + "Like before, let's plot the marker density after a few steps of simulation (each call to `step()` now updates all four simulations). Note that the boundaries between the four simulations are not visible in the image, but it shows four completely separate density states. The different inflow positions in conjunction with the solid wall boundaries (zero Dirichlet for velocity, and Neumann for pressure), result in four different end states of the simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#pylab.imshow(np.concatenate(fluid.density.data[...,0], axis=1), origin='lower', cmap='magma')\n", + "fig, axes = pylab.subplots(1, 4, figsize=(20, 4))\n", + "for i in range(inflow.shape.nbatch):\n", + " axes[i].imshow(smoke.values.nbatch[i].numpy('y,x'), origin='lower', cmap='magma')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**TODO** add labels...\n", + "\n", + "Now we see four simulations, (0) to (3). This final density of simulation (0), with the curved plume on the far left, will be our **reference state**, while the initial velocity of the other three will be modified in the optimization procedure below." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rdSTbMoaS0Uz" + }, + "source": [ + "## Differentiation\n", + "\n", + "The simulation we just computed was using purely (non-differentiable) operations from numpy.\n", + "To enable differentiability, we need to build a TensorFlow graph that computes this result. \n", + "\n", + "This can be achieved by changing the import statement to [`from phi.tf.flow import *`](https://tum-pbs.github.io/PhiFlow/phi/tf/flow.html) (or [`phi.torch.flow`](https://tum-pbs.github.io/PhiFlow/phi/torch/flow.html) for PyTorch).\n", + "Tensors created after this import will be allocated using TensorFlow and operations on these will be executed with TensorFlow.\n", + "Note that this will make use of a GPU through CUDA if your TensorFlow version supports it, and potentially custom CUDA operators of phiflow (if you dont have those compiled you might see a warning below, which you can safely ignore)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "id": "mphMP0sYIOz-" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Could not load resample cuda libraries: CUDA binaries not found at /Users/thuerey/Dropbox/mbaDevelSelected/phiflow-v2/phi/tf/cuda/build/resample.so. Run \"python setup.py tf_cuda\" to compile them\n" + ] + } + ], + "source": [ + "from phi.tf.flow import * # Causes deprecation warnings with TF 1.15\n", + "import pylab\n", + "# ### session = Session(None) # Used to run the TensorFlow graph" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3mpyowRYUSS4" + }, + "source": [ + "Now that we have imported `phi.tf.flow`, let's set up the simulation just like before. But now, the initial velocity state that we start from will be a variable quantity that we can modify. Then we can optimize these initial velocities so that all simulations arrive at a final state that is similar to the first simulation from the previous example. I.e., the state shown in the left-most image above.\n", + "\n", + "This is a fairly tough task: we're producing diffent dynamics by changing the boundary conditions (the marker inflow position), and an optimizer should now find a single initial velocity state, that gives the same state as simulation `0` above at $t=20$. Thus, after 20 steps the simulation should reproduce a different set of boundary conditions from the velocity state. It would be much easier to simply change the position of the marker inflow to arrive at this goal, but -- to make things a bit more difficult and interesting here -- the inflow is _not_ a degree of freedom. The optimizer can only change the velocity $\\mathbf{u}$ at time $t=0$.\n", + "\n", + "To achieve this, we'll run the full chain of steps for the simulation over time in TensorFlow, and track the gradients for the initial velocity state at $t=0$ to be modified in the optimization.\n", + "\n", + "**REMOVE we create a TensorFlow variable for the velocity at t=0.\n", + "It is initialized with zeros (like with the NumPy simulation above) and can later be used as a target for optimization.**" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "NlJMJikaHOL6" + }, + "outputs": [], + "source": [ + "domain = Domain(x=32, y=40, boundaries=CLOSED, bounds=Box[0:32, 0:40])\n", + "sphere_centers = [(10.,5.), (12.,5.), (19.,5.), (16.,5.)]\n", + "inflow_location = math.tensor(sphere_centers, names='inflow_loc,vector', convert=True)\n", + "inflow = domain.grid(Sphere(center=inflow_location, radius=3)) * 0.6\n", + "\n", + "# world = World()\n", + "# fluid = world.add(Fluid(Domain([40, 32], boundaries=CLOSED), buoyancy_factor=0.05, batch_size=4), physics=IncompressibleFlow())\n", + "# world.add(Inflow(Sphere(center=centers, radius=3), rate=0.2));\n", + "# fluid.velocity = variable(fluid.velocity) # create TensorFlow variable\n", + "# initial_state = fluid.state # Remember the state at t=0 for later visualization\n", + "# session.initialize_variables()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can verify that tensors are now backed by TensorFlow with the following `print` statement." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensorflow.python.framework.ops.EagerTensor" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(inflow.values.native())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vSdGIEzCgq5-" + }, + "source": [ + "Note that tensors created with NumPy will keep on using NumPy/SciPy operations unless a TensorFlow tensor is also passed to the same operation.\n", + "\n", + "**CONTINUE**\n", + "\n", + "The simulation now contains variables in the initial state.\n", + "Since all later states depend on the value of the variable, the `step` method cannot directly compute concrete state values.\n", + "Instead, `world.step` will extend the TensorFlow graph by the operations needed to perform the step.\n", + "\n", + "To execute the graph with actual data, we can use `session.run`, just like with regular TensorFlow 1.x. While `run` would usually be used to infer predictions from a learning model, it now executes the graph of simulation steps." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "wSrIezfWHjcQ" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'world' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mworld\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mstep\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 2\u001b[0m \u001b[0mpylab\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mconcatenate\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msession\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mrun\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfluid\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdensity\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdata\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m...\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0maxis\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'lower'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'magma'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'world' is not defined" + ] + } + ], + "source": [ + "world.step()\n", + "pylab.imshow(np.concatenate(session.run(fluid.density).data[...,0], axis=1), origin='lower', cmap='magma')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "iJc6UdYHhtOH" + }, + "source": [ + "Let's build a graph for the full simulation." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "b9xHtdDQRrjL" + }, + "outputs": [], + "source": [ + "for step in range(20):\n", + " print('Building graph for time step %d' % step)\n", + " world.step(dt=1.5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "2VQ92g2rs6wM" + }, + "source": [ + "When calling `session.run` now, the full simulation is evaluated using TensorFlow operations.\n", + "This will take advantage of your GPU, if available.\n", + "If you compile ΦFlow with [CUDA support](https://github.com/tum-pbs/PhiFlow/blob/master/documentation/Installation_Instructions.md), the TensorFlow graph will also use optimized operators for efficient simulation and training runs.\n", + "\n", + "The `session.run()` call of the following code block will now retrieve the final fluid density, and for that it actually needs to process all 20 simulation steps of the TF graph that we just constructed." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TA6Ibs-mXsTc" + }, + "outputs": [], + "source": [ + "print('Computing frames...')\n", + "original_state = np.concatenate(session.run(fluid.density).data[...,0], axis=1)\n", + "pylab.imshow(original_state, origin='lower', cmap='magma')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "IClfRMfoyGUa" + }, + "source": [ + "Next, we define the *loss* function. This is the value we want to decrease via optimization.\n", + "For this example, we want the marker densities of all final simulation states to match the left-most one, called `target`, in terms of an $L^2$ norm.\n", + "\n", + "For the optimizer, we choose again gradient descent for this example." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "7KPpyIwjYETi" + }, + "outputs": [], + "source": [ + "target = session.run(fluid.density).data[0,...]\n", + "loss = math.l2_loss(fluid.density.data[1:,...] - target)\n", + "optim = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss)\n", + "session.initialize_variables()\n", + "\n", + "print('Initial loss: %f' % session.run(loss))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "AALD66-N0U5F" + }, + "source": [ + "With the loss and optimizer set up, all that's left is to run the actual optimization." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "pvvF6xqmaRLX" + }, + "outputs": [], + "source": [ + "for optim_step in range(100):\n", + " _, loss_value = session.run([optim, loss])\n", + " if optim_step<3 or optim_step%10==0: \n", + " print('Optimization step %d, loss %f %s' % (optim_step, loss_value, '' if optim_step else '. The first step sets up the adjoint graph.'))\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The loss should have gone down significantly, from above 60 to below 40, and now we can visualize how well the reconstruction for the last frame turned out for simulations 1 to 3." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "SQBtCmhZaYYj" + }, + "outputs": [], + "source": [ + "optimized_state = np.concatenate(session.run(fluid.density).data[...,0], axis=1)\n", + "pylab.title(\"Original state at t=20 (top), and optimized version (bottom):\")\n", + "pylab.imshow( np.concatenate([optimized_state, original_state],axis=0), origin='lower', cmap='magma')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "HP7aDQfpKifp" + }, + "source": [ + "Naturally, the image on the left is the same (this is simulation (0), our reference), and the other three simulations now exhibit a noticeable curved shape towards the left. This is especially visible for the far right simulation (3), which was moving straight up in its original state, and now has an off-center plume shape that tries to match the reference on the left. \n", + "\n", + "Note that this simulation (like both others) needs to \"work\" with a fixed inflow, hence it cannot simply \"produce\" marker density out of the blue to match the target. Also it needs to take into account how the non-linear model equations change the state of the system over the course of 20 time steps. So the optimization goal is quite tough, and it is not possible to exactly satisfy the constraints to match simulation (0) in this scenario. This is exactly what makes it an interesting test case, though.\n", + "\n", + "Now we can also have a look at the now-optimized initial velocity field. Here we see the y-components (from `data[...,0]`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "i7ZahlUudex8" + }, + "outputs": [], + "source": [ + "optimized_velocity_field = session.run(initial_state.velocity).at_centers()\n", + "\n", + "pylab.title('Initial y-velocity (optimized)')\n", + "pylab.imshow(np.concatenate(optimized_velocity_field.data[...,0], axis=1), origin='lower')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This nicely shows how the initial perturbation of the velocity field grows for the larger inflow deviations towards the right:\n", + "\n", + "For comlpeteness, here are the x-components:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Pqw5BDxmdkut" + }, + "outputs": [], + "source": [ + "pylab.title('Initial x-velocity (optimized)')\n", + "pylab.imshow(np.concatenate(optimized_velocity_field.data[...,1], axis=1), origin='lower')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ooqVxCPM8PXl" + }, + "source": [ + "This example illustrates how the differentiable physics approach can easily be extended towards significanlty more complex PDEs. Above, we've optimized for a mini-batch of 20 steps of a full Navier-Stokes solver.\n", + "\n", + "This is a powerful basis to bring NNs into the picture! As you might have noticed, our degrees of freedom were still a regular grid, and we've solved a single inverse problem. There was more than one case to solve, but nonetheless no question of generalization and no neural network structure." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [], + "name": "Differentiable Physics with Fluid Simulations.ipynb", + "provenance": [] + }, + "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.5" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/overview-burgers-forw-v2.ipynb b/overview-burgers-forw-v2.ipynb index aae86fc..472b74a 100644 --- a/overview-burgers-forw-v2.ipynb +++ b/overview-burgers-forw-v2.ipynb @@ -8,7 +8,7 @@ "\n", "This chapter will give an introduction for how to run _forward_, i.e., regular simulations starting with a given initial state and approximating a later state numerically, with ΦFlow.\n", "\n", - "Burgers equations is a very simple, yet non-linear and non-trivial, model equation, and hence a very good starting point for experiments. It contains an advection and a diffusion term, and can lead to interesting shock formations due to a lack of additional constraints:\n", + "Burgers equations is a very simple, yet non-linear and non-trivial, model equation, and hence a very good starting point for experiments. It contains an advection term (motion / transport) and a diffusion term (dissipation due to the second law of thermodynamics). Burgers equation can already lead to interesting shock formations, and is given by:\n", "$\n", " \\frac{\\partial u}{\\partial{t}} + u \\nabla u =\n", " \\nu \\nabla\\cdot \\nabla u\n", @@ -16,7 +16,7 @@ "\n", "Let's get some preliminaries out of the way: we'll import the ΦFlow library, and define our simulation domain with $n=128$ cells as discretization points for the 1D velocity $u$ in a periodic domain $\\Omega$ for the interval $[-1,1]$. We'll use 32 time `steps` for a time interval of 1, giving us `dt=1/32`. Additionally, we'll use a viscosity of $\\nu=0.01/\\pi$.\n", "\n", - "We'll also define an initial state given by $-\\text{sin}(\\pi x$ in the numpy array `initial`, which we'll use to initialize the velocity $u$ in the simulation in the next cell.\n", + "We'll also define an initial state given by $-\\text{sin}(\\pi x)$ in the numpy array `initial`, which we'll use to initialize the velocity $u$ in the simulation in the next cell.\n", "\n", "**Note:** Below, the first command with a \"!\" prefix installs the [ΦFlow Python package from GitHub](https://github.com/tum-pbs/PhiFlow) via `pip` in your python environment. (You can skip or modify this command if necessary, depending on your system.)" ] @@ -25,74 +25,85 @@ "cell_type": "code", "execution_count": 1, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(128,)" - ] - }, - "execution_count": 1, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#!pip install --upgrade --quiet phiflow\n", - "from phi.flow import *\n", - "\n", - "# run with phiflow\n", - "n = 128\n", - "steps = 32\n", - "dt = 1./steps\n", - "nu = 0.01/np.pi\n", - "\n", - "initial = np.asarray( [-np.sin(np.pi * x) * 1. for x in np.linspace(-1,1,n)] ) # 1D array\n", - "#initial = np.asarray( [ [-np.sin(np.pi * x) * 1.] for x in np.linspace(-1,1,n)] ) # with additional component channel\n", - "initial.shape" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Next we can define `domain` to contain $\\Omega$, as outlined above periodically for $[-1,1]$, and initialize a 1D `velocity` from the `initial` array.\n", - "\n", - "Just to illustrate, we'll also print some info about the velocity object: it's `phiflow.math` tensor with a size of 128. Note that the actual grid content is contained in the `values` of the grid. Below we're printing the first five values via the conversion to a numpy array with `numpy()`." - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Velocity tensor shape: (x=128, vector=1)\n", - "Velocity tensor type: \n", - "Velocity tensor content: [[0.5569957 ]\n", - " [0.5911083 ]\n", - " [0.62823397]\n", - " [0.68026114]\n", - " [0.72364265]]\n" + "Using phiflow version: 2.0.0\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/Users/thuerey/Dropbox/mbaDevelSelected/phiflow-v2/phi/math/backend/_scipy_backend.py:255: RuntimeWarning: overflow encountered in exp\n", - " return np.exp(x)\n" + "/Users/thuerey/miniconda3/envs/tf/lib/python3.8/_collections_abc.py:743: MatplotlibDeprecationWarning: The global colormaps dictionary is no longer considered public API.\n", + " for key in self._mapping:\n", + "/Users/thuerey/miniconda3/envs/tf/lib/python3.8/_collections_abc.py:744: MatplotlibDeprecationWarning: The global colormaps dictionary is no longer considered public API.\n", + " yield (key, self._mapping[key])\n" + ] + } + ], + "source": [ + "#!pip install --upgrade --quiet phiflow\n", + "#!pip install --upgrade --quiet git+https://github.com/tum-pbs/PhiFlow@develop\n", + "\n", + "from phi.flow import *\n", + "import phi\n", + "print(\"Using phiflow version: {}\".format(phi.__version__))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now that we've loaded phiflow, we can start defining some globals and constants. The `initial` array contains the aforementioned sine wave that we'll use to produce a nice shock in the center of our domain." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "n = 128\n", + "steps = 32\n", + "dt = 1./steps\n", + "nu = 0.01/np.pi\n", + "\n", + "initial = np.asarray( [-np.sin(np.pi * x) * 1. for x in np.linspace(-1,1,n)] ) # 1D array\n", + "#initial = np.asarray( [ [-np.sin(np.pi * x) * 1.] for x in np.linspace(-1,1,n)] ) # with additional component channel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next we can define the `domain` to contain $\\Omega$, as outlined above periodically for $[-1,1]$. We also initialize a 1D `velocity` from the `initial` array.\n", + "\n", + "Just to illustrate, we'll also print some info about the velocity object: it's a `phiflow.math` tensor with a size of 128. Note that the actual grid content is contained in the `values` of the grid. Below we're printing the first five entries via the conversion to a numpy array with `numpy()`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Velocity tensor shape: (x=128)\n", + "Velocity tensor type: \n", + "Velocity tensor content: [1.2246469e-16 4.9453720e-02 9.8786421e-02 1.4787737e-01 1.9660644e-01]\n" ] } ], "source": [ "domain = Domain(x=n, boundaries=PERIODIC, bounds=Box[-1:1])\n", - "#velocity = domain.staggered_grid(initial)\n", - "#velocity = domain.grid(initial)\n", - "velocity = domain.grid(Noise(vector=1))\n", + "velocity = domain.scalar_grid(initial)\n", + "#velocity = domain.grid(Noise(vector=1))\n", + "#dont use: velocity = domain.staggered_grid(initial) , velocity = domain.grid(initial) \n", "\n", "print(\"Velocity tensor shape: \" + format( velocity.shape )) # == velocity.values.shape\n", "print(\"Velocity tensor type: \" + format( type(velocity.values) ))\n", @@ -110,18 +121,14 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "New velocity content at t=1.0: [[0.15099575]\n", - " [0.16271012]\n", - " [0.17444186]\n", - " [0.18618482]\n", - " [0.19793215]]\n" + "New velocity content at t=1.0: [0.00274862 0.01272991 0.02360343 0.03478042 0.0460869 ]\n" ] } ], @@ -141,33 +148,33 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Here we're actually collecting all time steps in the `vels` list. This is not necessary in general (and could consume lots of memory for long-running sims), but useful here to show the evolution of the velocity states.\n", + "Here we're actually collecting all time steps in the list `vels`. This is not necessary in general (and could consume lots of memory for long-running sims), but useful here to plot the evolution of the velocity states later on.\n", "\n", - "The print statements print a few of the velocities and already shows that something is happening in our simulation, but it's difficult to get an intuition for the behavior of the PDE just from these numbers. Hence, let's visualize the states over time to show what is happening.\n", + "The print statements print a few of the velocity entries, and already shows that something is happening in our simulation, but it's difficult to get an intuition for the behavior of the PDE just from these numbers. Hence, let's visualize the states over time to show what is happening.\n", "\n", "## Visualization\n", "\n", - "We can visualize them in graph: the following code shows the initial state in blue, and then times $10/32, 20/32, 1$ in green, cyan and purple. " + "We can visualize this 1D case easily in a graph: the following code shows the initial state in blue, and then times $10/32, 20/32, 1$ in green, cyan and purple. " ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 4, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -180,12 +187,11 @@ ], "source": [ "# we only need \"velocity.data\" from each phiflow state\n", - "vels = [x.values.numpy() for x in velocities]\n", + "#vels = [v.values.numpy('x') for v in velocities]\n", + "vels = [v.values.numpy('x,vector') for v in velocities] # vel vx\n", "\n", - "# print(vels[0][0,:,0].shape)\n", - "# print(vels[0].shape[1])\n", - "\n", - "import matplotlib.pyplot as plt\n", + "#import matplotlib.pyplot as plt\n", + "import pylab as plt\n", "\n", "fig = plt.figure().gca()\n", "fig.plot(np.linspace(-1,1,len(vels[ 0].flatten())), vels[ 0].flatten(), lw=2, color='blue')\n", @@ -198,7 +204,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "This nicely shows the shock developing in the center of our domain, which forms from the collision of the two initial bumps which are located left and right of the center.\n", + "This nicely shows the shock developing in the center of our domain, which forms from the collision of the two initial velocity \"bumps\", the positive one on left (moving right) and the negative one right of the center (moving left).\n", "\n", "As these lines can overlap quite a bit we'll also use a different visualization in the following chapters that shows the evolution over the course of all time steps in a 2D image. Our 1D domain will be shown along the Y-axis, and each point along X will represent one time step.\n", "\n", @@ -207,7 +213,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 20, "metadata": {}, "outputs": [ { @@ -217,11 +223,24 @@ "Vels array shape: (128, 33, 1)\n" ] }, + { + "ename": "TypeError", + "evalue": "show() got an unexpected keyword argument 'size'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 18\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msavez_compressed\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"./temp/burgers-groundtruth-solution.npz\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mreshape\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvels_img\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0msteps\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# remove batch & channel dimension\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 19\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m \u001b[0mshow_state\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mvels_img\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;32m\u001b[0m in \u001b[0;36mshow_state\u001b[0;34m(a)\u001b[0m\n\u001b[1;32m 9\u001b[0m \u001b[0mim\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0ma\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0morigin\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'upper'\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mcmap\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'magma'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 10\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolorbar\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mim\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m#, ax=axes[i])\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 11\u001b[0;31m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 12\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 13\u001b[0m \u001b[0;31m#vels_img = np.asarray( np.stack(vels), dtype=np.float32 ).transpose() # no component channel\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;32m~/miniconda3/envs/tf/lib/python3.8/site-packages/matplotlib/pyplot.py\u001b[0m in \u001b[0;36mshow\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m 351\u001b[0m \"\"\"\n\u001b[1;32m 352\u001b[0m \u001b[0m_warn_if_gui_out_of_main_thread\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 353\u001b[0;31m \u001b[0;32mreturn\u001b[0m \u001b[0m_backend_mod\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mshow\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m*\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m**\u001b[0m\u001b[0mkwargs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 354\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 355\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mTypeError\u001b[0m: show() got an unexpected keyword argument 'size'" + ] + }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ - "
" + "
" ] }, "metadata": { @@ -239,9 +258,12 @@ "\n", " a = np.reshape( a, [a.shape[0],a.shape[1]*a.shape[2]] )\n", " #print(\"resulting image size\" +format(a.shape))\n", - " plt.imshow(a, origin='upper', cmap='magma')\n", - " \n", - "vels_img = np.asarray( np.concatenate(vels, axis=-1), dtype=np.float32 )\n", + " im = plt.imshow(a, origin='upper', cmap='magma')\n", + " plt.colorbar(im) #, ax=axes[i])\n", + " #plt.show(size=(5, 5))\n", + " \n", + "#vels_img = np.asarray( np.stack(vels), dtype=np.float32 ).transpose() # no component channel\n", + "vels_img = np.asarray( np.concatenate(vels, axis=-1), dtype=np.float32 ) # vel vx\n", "vels_img = np.reshape(vels_img, list(vels_img.shape)+[1] ) ; print(\"Vels array shape: \"+format(vels_img.shape))\n", "\n", "# save for comparison with reconstructions later on\n", @@ -286,7 +308,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.8.5" } }, "nbformat": 4, diff --git a/overview-ns-forw-v2.ipynb b/overview-ns-forw-v2.ipynb index a81b047..ff5c46d 100644 --- a/overview-ns-forw-v2.ipynb +++ b/overview-ns-forw-v2.ipynb @@ -32,7 +32,18 @@ "id": "da1uZcDXdVcF", "outputId": "1082dc87-796c-4b57-e72e-5790fc1444c9" }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/thuerey/miniconda3/envs/tf/lib/python3.8/_collections_abc.py:743: MatplotlibDeprecationWarning: The global colormaps dictionary is no longer considered public API.\n", + " for key in self._mapping:\n", + "/Users/thuerey/miniconda3/envs/tf/lib/python3.8/_collections_abc.py:744: MatplotlibDeprecationWarning: The global colormaps dictionary is no longer considered public API.\n", + " yield (key, self._mapping[key])\n" + ] + } + ], "source": [ "#!pip install --upgrade --quiet phiflow\n", "from phi.flow import * # The Dash GUI is not supported on Google Colab, ignore the warning\n", @@ -104,7 +115,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -113,7 +124,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -235,7 +246,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 6, @@ -244,7 +255,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -309,7 +320,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 7, @@ -318,7 +329,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -382,7 +393,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.8.5" } }, "nbformat": 4,