From 362280677dd32890adbe77ad934fdf6961b8b2b1 Mon Sep 17 00:00:00 2001 From: Frederik Hennig <frederik.hennig@fau.de> Date: Fri, 14 Aug 2020 09:20:38 +0200 Subject: [PATCH] Codegen Tutorial: Added CMake, Python and C++ - Added folder 'codegen' to 'apps/tutorials' - Implemented heat equation code generation in python - Implemented C++ application for running the generated code - Added CMake build files for code generation tutorial --- .gitignore | 4 + apps/tutorials/CMakeLists.txt | 3 + .../codegen/01_CodegenHeatEquation.cpp | 170 +++++ .../codegen/01_CodegenHeatEquation.dox | 262 ++++++++ apps/tutorials/codegen/CMakeLists.txt | 11 + .../codegen/Heat Equation Kernel.ipynb | 587 ++++++++++++++++++ apps/tutorials/codegen/HeatEquationKernel.py | 25 + doc/Mainpage.dox | 5 + doc/pics/tutorial_codegen01_paraview.png | Bin 0 -> 110061 bytes 9 files changed, 1067 insertions(+) create mode 100644 apps/tutorials/codegen/01_CodegenHeatEquation.cpp create mode 100644 apps/tutorials/codegen/01_CodegenHeatEquation.dox create mode 100644 apps/tutorials/codegen/CMakeLists.txt create mode 100644 apps/tutorials/codegen/Heat Equation Kernel.ipynb create mode 100644 apps/tutorials/codegen/HeatEquationKernel.py create mode 100644 doc/pics/tutorial_codegen01_paraview.png diff --git a/.gitignore b/.gitignore index 91448c9a7..88f876449 100644 --- a/.gitignore +++ b/.gitignore @@ -26,6 +26,8 @@ qrc_* /CMakeSettings.json /.vs +# Visual Studio Code +/.vscode # CLion *.idea @@ -50,6 +52,8 @@ logfile*.txt # Compiled python *.pyc +# Jupyter Notebook +**/.ipynb_checkpoints # Blockforest saves *.sav diff --git a/apps/tutorials/CMakeLists.txt b/apps/tutorials/CMakeLists.txt index 8a5887e69..4eb4eb533 100644 --- a/apps/tutorials/CMakeLists.txt +++ b/apps/tutorials/CMakeLists.txt @@ -6,3 +6,6 @@ add_subdirectory(pe) if( WALBERLA_BUILD_WITH_CUDA ) add_subdirectory(cuda) endif() +if( WALBERLA_BUILD_WITH_CODEGEN ) + add_subdirectory(codegen) +endif() \ No newline at end of file diff --git a/apps/tutorials/codegen/01_CodegenHeatEquation.cpp b/apps/tutorials/codegen/01_CodegenHeatEquation.cpp new file mode 100644 index 000000000..361ebf764 --- /dev/null +++ b/apps/tutorials/codegen/01_CodegenHeatEquation.cpp @@ -0,0 +1,170 @@ +//====================================================================================================================== +// +// This file is part of waLBerla. waLBerla is free software: you can +// redistribute it and/or modify it under the terms of the GNU General Public +// License as published by the Free Software Foundation, either version 3 of +// the License, or (at your option) any later version. +// +// waLBerla is distributed in the hope that it will be useful, but WITHOUT +// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License +// for more details. +// +// You should have received a copy of the GNU General Public License along +// with waLBerla (see COPYING.txt). If not, see <http://www.gnu.org/licenses/>. +// +//! \file 01_CodegenHeatEquation.cpp +//! \author Frederik Hennig <frederik.hennig@fau.de> +// +//====================================================================================================================== + +#include "blockforest/Initialization.h" +#include "blockforest/communication/UniformBufferedScheme.h" + +#include "core/Environment.h" +#include "core/math/Constants.h" + +#include "field/AddToStorage.h" +#include "field/communication/PackInfo.h" +#include "field/vtk/VTKWriter.h" + +#include "pde/boundary/Neumann.h" + +#include "stencil/D2Q9.h" + +#include "timeloop/SweepTimeloop.h" + +#include "HeatEquationKernel.h" + +namespace walberla +{ +typedef GhostLayerField< real_t, 1 > ScalarField; + +void swapFields(StructuredBlockForest& blocks, BlockDataID uID, BlockDataID uTmpID) +{ + for (auto block = blocks.begin(); block != blocks.end(); ++block) + { + ScalarField* u = block->getData< ScalarField >(uID); + ScalarField* u_tmp = block->getData< ScalarField >(uTmpID); + + u->swapDataPointers(u_tmp); + } +} + +void initDirichletBoundaryNorth(shared_ptr< StructuredBlockForest > blocks, BlockDataID uId, BlockDataID uTmpId) +{ + for (auto block = blocks->begin(); block != blocks->end(); ++block) + { + if (blocks->atDomainYMaxBorder(*block)) + { + ScalarField* u = block->getData< ScalarField >(uId); + ScalarField* u_tmp = block->getData< ScalarField >(uTmpId); + + CellInterval xyz = u->xyzSizeWithGhostLayer(); + + xyz.yMin() = xyz.yMax(); + for (auto cell = xyz.begin(); cell != xyz.end(); ++cell) + { + const Vector3< real_t > p = blocks->getBlockLocalCellCenter(*block, *cell); + // Set the dirichlet boundary to f(x) = 1 + sin(x) * x^2 + real_t v = real_c(1.0 + std::sin(2 * math::pi * p[0]) * p[0] * p[0]); + u->get(*cell) = v; + u_tmp->get(*cell) = v; + } + } + } +} + +int main(int argc, char** argv) +{ + mpi::Environment env(argc, argv); + + ///////////////////////////// + /// SIMULATION PARAMETERS /// + ///////////////////////////// + + // Ensure matching aspect ratios of cells and domain. + const uint_t xCells = uint_c(25); + const uint_t yCells = uint_c(25); + + const real_t xSize = real_c(1.0); + const real_t ySize = real_c(1.0); + + const uint_t xBlocks = uint_c(1); + const uint_t yBlocks = uint_c(1); + + const uint_t processes = uint_c(MPIManager::instance()->numProcesses()); + + if (processes != xBlocks * yBlocks) + { WALBERLA_ABORT("The number of processes must be equal to the number of blocks!"); } + + const real_t dx = xSize / real_c(xBlocks * xCells + uint_t(1)); + const real_t dy = ySize / real_c(yBlocks * yCells + uint_t(1)); + + WALBERLA_CHECK_FLOAT_EQUAL(dx, dy); + + const real_t dt = real_c(1e-4); + const real_t kappa = real_c(1.0); + + /////////////////////////// + /// BLOCK STORAGE SETUP /// + /////////////////////////// + + auto aabb = math::AABB(real_c(0.5) * dx, real_c(0.5) * dy, real_c(0.0), xSize - real_c(0.5) * dx, + ySize - real_c(0.5) * dy, dx); + + shared_ptr< StructuredBlockForest > blocks = blockforest::createUniformBlockGrid( + aabb, xBlocks, yBlocks, uint_c(1), xCells, yCells, 1, true, false, false, false); + + ////////////// + /// FIELDS /// + ////////////// + + BlockDataID uFieldId = field::addToStorage< ScalarField >(blocks, "u", real_c(0.0), field::fzyx, uint_c(1)); + BlockDataID uTmpFieldId = field::addToStorage< ScalarField >(blocks, "u_tmp", real_c(0.0), field::fzyx, uint_c(1)); + + ///////////////////// + /// COMMUNICATION /// + ///////////////////// + + blockforest::communication::UniformBufferedScheme< stencil::D2Q9 > commScheme(blocks); + commScheme.addPackInfo(make_shared< field::communication::PackInfo< ScalarField > >(uFieldId)); + + ////////////////////////// + /// DIRICHLET BOUNDARY /// + ////////////////////////// + + initDirichletBoundaryNorth(blocks, uFieldId, uTmpFieldId); + + //////////////////////// + /// NEUMANN BOUNDARY /// + //////////////////////// + + pde::NeumannDomainBoundary< ScalarField > neumann(*blocks, uFieldId); + + neumann.excludeBoundary(stencil::N); + neumann.excludeBoundary(stencil::B); + neumann.excludeBoundary(stencil::T); + + //////////////// + /// TIMELOOP /// + //////////////// + + SweepTimeloop timeloop(blocks, uint_c(2e4)); + + timeloop.add() << BeforeFunction(commScheme, "Communication") << BeforeFunction(neumann, "Neumann Boundaries") + << Sweep(pystencils::HeatEquationKernel(uFieldId, uTmpFieldId, dt, dx, kappa), "HeatEquationKernel") + << AfterFunction([blocks, uFieldId, uTmpFieldId]() { swapFields(*blocks, uFieldId, uTmpFieldId); }, + "Swap"); + + auto vtkWriter = field::createVTKOutput< ScalarField, float >( uFieldId, *blocks, "temperature", uint_c(200), uint_c(0) ); + vtkWriter(); + timeloop.addFuncAfterTimeStep(vtkWriter, "VTK"); + + timeloop.run(); + + return EXIT_SUCCESS; +} +} + +int main(int argc, char** argv) { walberla::main(argc, argv); } diff --git a/apps/tutorials/codegen/01_CodegenHeatEquation.dox b/apps/tutorials/codegen/01_CodegenHeatEquation.dox new file mode 100644 index 000000000..14fc2fa6e --- /dev/null +++ b/apps/tutorials/codegen/01_CodegenHeatEquation.dox @@ -0,0 +1,262 @@ +namespace walberla{ + +/** +\page tutorial_codegen01 Tutorial - Code Generation 1: Explicit Solver for the Heat Equation + +This tutorial will focus on using the <a target="_blank" href="https://pycodegen.pages.i10git.cs.fau.de/pystencils/">pystencils</a> code generation framework for generating waLBerla sweeps. It covers the workflow for converting a partial differential equation (PDE) written as a symbolic description to a working waLBerla simulation app. + +The final result of this tutorial will be a waLBerla application simulating a heat source warming up a rectangular plate from one side. In contrast to \ref tutorial_pde02, we will use an explicit time-stepping scheme here. + +This tutorial should not function as an introduction to pystencils itself but provide an overview of the code generation toolchain for the waLBerla framework. A detailed introduction to pystencils can be found <a target="_blank" href="https://pycodegen.pages.i10git.cs.fau.de/pystencils/sphinx/tutorials.html">here</a>. + +\section equation The Equation + +In this tutorial, we will solve the two-dimensional <a target="_blank" href="https://en.wikipedia.org/wiki/Heat_equation">heat equation</a> which describes the flow of heat through a homogenous medium. We can write it as +\f[ + \frac{\partial u}{\partial t} = \kappa \cdot \Delta u +\f] +where \f$ \kappa \f$ is the medium's diffusion coefficient, \f$ \Delta \f$ is the Laplace operator which is short-hand for the divergence of the gradient, and \f$ u(x, y, t) \f$ is the unknown temperature distribution at the coordinate \f$ (x,y) \f$ at time \f$ t \f$. In the next section we will show how to express the equation using pystencils which builds upon <a target="_blank" href="https://www.sympy.org/en/index.html">sympy</a> for describing mathematical expressions symbolically. Furthermore, we automatically derive a numerical approximation for the problem. +\section discretization_and_codegen Building the Kernel in pystencils + +For interactive devolvement, the next section can be written in a <a target="_blank" href="https://jupyter.org/">Jupyter notebook</a>. Due to the symbolic representation provided by sympy all equations can be viewed in a \f$ \LaTeX \f$ style format. + +First, we introduce the variables contained in the PDE and its discretization as symbols. For the two-grid algorithm, we require one source field `u` and one destination field `u_tmp`. Both are set as generic 2-dimensional fields. We explicitly set their memory layout to `fzyx`. Both waLBerla and pystencils support two kinds of memory layouts. The short `fzyx` lists the four domain dimensions (three spatial, one for values per cell) in the order of arrangement in memory. `fzyx` describes a Struct of Arrays (SOA) layout where the domain is split along `f` and then linearized. When iterating, the outermost loop runs over `f`, and the innermost loop runs over `x`. The alternative is an %Array of Structs layout (AOS) which is designated `zyxf`, iterating over `f` in the innermost loop. In our case, where we only have one value per cell, it does not matter which layout is selected. In contrast, for simulating an Advection-Diffusion-Process with multiple, independent particle distributions, `fzyx` performs better in most cases as it improves data locality and enables vectorization (SIMD, SIMT). For more information on SOA and AOS, consider <a target="_blank" href="https://software.intel.com/content/www/us/en/develop/articles/memory-layout-transformations.html">this</a> article. + +\code +u, u_tmp = ps.fields("u, u_tmp: [2D]", layout='fzyx') +kappa = sp.Symbol("kappa") +dx = sp.Symbol("dx") +dt = sp.Symbol("dt") +\endcode + +With the pystencils buildings blocks, we can directly define the time and spatial derivative of the PDE. + +\code +heat_pde = ps.fd.transient(u) - kappa * ( ps.fd.diff( u, 0, 0 ) + ps.fd.diff( u, 1, 1 ) ) +\endcode + +Printing `heat_pde` inside a Jupyter notebook shows the equation as: +\f[ + - \kappa \left({\partial_{0} {\partial_{0} {{u}_{(0,0)}}}} + {\partial_{1} {\partial_{1} {{u}_{(0,0)}}}}\right) + \partial_t u_{C} +\f] + +Next, the PDE will be discretized. We use the `Discretization2ndOrder` class to apply finite differences discretization to the spatial components, and explicit Euler discretization for the time step. + +\code +discretize = ps.fd.Discretization2ndOrder(dx=dx, dt=dt) +heat_pde_discretized = discretize(heat_pde) +\endcode + +Printing `heat_pde_discretized` reveals + +\f[ +{{u}_{(0,0)}} + dt \kappa \left(\frac{- 2 {{u}_{(0,0)}} + {{u}_{(1,0)}} + {{u}_{(-1,0)}}}{dx^{2}} + \frac{- 2 {{u}_{(0,0)}} + {{u}_{(0,1)}} + {{u}_{(0,-1)}}}{dx^{2}}\right). +\f] + +This equation can be simplified by combining the two fractions on the right-hand side. Furthermore, we would like to pre-calculate the division outside the loop of the compute kernel. To achieve this, we will first apply the simplification functionality of sympy, and then replace the division by introducing a subexpression. + +\code +heat_pde_discretized = heat_pde_discretized.args[1] + heat_pde_discretized.args[0].simplify() + +@ps.kernel +def update(): + u_tmp.center @= heat_pde_discretized + +ac = ps.AssignmentCollection(update) +ac = ps.simp.simplifications.add_subexpressions_for_divisions(ac) +\endcode + +The resulting subexpression and the simplified assignment are now combined inside an `AssignmentCollection`. Printing `ac` lists the subexpression +\f[ + \xi_{0} \leftarrow \frac{1}{dx^{2}} +\f] +and the main assignment +\f[ + {{u_tmp}_{(0,0)}} \leftarrow {{u}_{(0,0)}} + dt \kappa \xi_{0} \left(- 4 {{u}_{(0,0)}} + {{u}_{(1,0)}} + {{u}_{(0,1)}} + {{u}_{(0,-1)}} + {{u}_{(-1,0)}}\right). +\f] + +This completes our symbolic description of the kernel. In the next section, we will proceed to putting all of the above code inside a Python script which will then be called to generate a C++ implementation of the kernel. + +Developing a numerical solver this way allows for a workflow where we can derive, test and improve our model interactively inside a Jupyter Notebook. We can use pystencils to generate and compile a parallelized kernel using OpenMP or CUDA. This kernel can then be included in small-scale prototype simulations and called as a python function. Once development on the numeric scheme itself is finished, we do not need to reimplement it in C++. Instead, we simply use the same code generation script to produce an implementation which is integrated with waLBlera for large-scale distributed-memory parallel simulations. In the tutorial folder, you can find Jupyter notebook demonstrating this workflow, including the code snippets from this section. + +\section walberla_buildsystem_codegen Generating a Sweep class from the kernel + +We will now use the waLBerla build system to generate a sweep from this symbolic representation. waLBerla makes use of pystencils' code generation functionality to produce an implementation of the kernel in C. It further builds a functor class around the generated C function which can then be included into a waLBerla application. + +We create a python file called *HeatEquationKernel.py* in our application folder. This file contains the python code we have developed above. Additionally, to `sympy` and `pystencils`, we add the import directive `from pystencils_walberla import CodeGeneration, generate_sweep`. At the end of the file, we add these two lines: + +\code +with CodeGeneration() as ctx: + generate_sweep(ctx, 'HeatEquationKernel', ac) +\endcode + +The `CodeGeneration` context and the function `generate_sweep` are provided by waLBerla. `generate_sweep` takes the desired class name and the update rule. It then generates the kernel and builds a C++ class around it. We choose `HeatEquationKernel` as the class name. Through the `CodeGeneration` context, the waLBerla build system gives us access to a list of CMake variables. With `ctx.cuda` for example, we can ask if waLBerla was built with support for using NVIDIA GPUs and thus we can directly generate CUDA code with pystencils. In the scope of this first tutorial, we will not make use of this. + +The code generation script will later be called by the build system while compiling the application. The complete script looks like this: + +\code +import sympy as sp +import pystencils as ps +from pystencils_walberla import CodeGeneration, generate_sweep + +u, u_tmp = ps.fields("u, u_tmp: [2D]", layout='fzyx') +kappa = sp.Symbol("kappa") +dx = sp.Symbol("dx") +dt = sp.Symbol("dt") +heat_pde = ps.fd.transient(u) - kappa * (ps.fd.diff(u, 0, 0) + ps.fd.diff(u, 1, 1)) + +discretize = ps.fd.Discretization2ndOrder(dx=dx, dt=dt) +heat_pde_discretized = discretize(heat_pde) +heat_pde_discretized = heat_pde_discretized.args[1] + heat_pde_discretized.args[0].simplify() + + +@ps.kernel +def update(): + u_tmp.center @= heat_pde_discretized + + +ac = ps.AssignmentCollection(update) +ac = ps.simp.simplifications.add_subexpressions_for_divisions(ac) + +with CodeGeneration() as ctx: + generate_sweep(ctx, 'HeatEquationKernel', ac) + +\endcode + +As a next step, we register the script with the CMake build system. Outside of our application folder, open *CMakeLists.txt* and add these lines (replace `codegen` by the name of your folder): +\code +if( WALBERLA_BUILD_WITH_CODEGEN ) + add_subdirectory(codegen) +endif() +\endcode + +The `if` block makes sure our application is only built if the CMake flag `WALBERLA_BUILD_WITH_CODEGEN` is set. In the application folder, create another *CMakeLists.txt* file. For registering a code generation target, the build system provides the `walberla_generate_target_from_python` macro. Apart from the target name, we need to pass it the name of our python script and the names of the generated C++ header and source files. Their names need to match the class name passed to `generate_sweep` in the script. Add the following lines to your *CMakeLists.txt*. + +\code +if( WALBERLA_BUILD_WITH_CODEGEN ) + walberla_generate_target_from_python( NAME CodegenHeatEquationKernel + FILE HeatEquationKernel.py + OUT_FILES HeatEquationKernel.cpp HeatEquationKernel.h ) +endif() +\endcode + +The build system is now ready to generate the code. Open a terminal, navigate to the *build* folder of waLBerla and run the CMake configuration as shown here: \ref setup_instructions. Make sure the flag `WALBERLA_BUILD_WITH_CODEGEN` is set to `ON`. Then, navigate to the application folder's copy inside the build directory (for this tutorial, that is *build/apps/tutorials/codegen*) and run `make`. A subfolder named *default_codegen* should appear, containing a C++ header and source file with the generated code. Those contain the functor class `HeatEquationKernel` implementing the kernel code as shown above, with the necessary boilerplate code to use it as a sweep. Just like the python kernel function, the sweep's constructor expects both fields `u` and `u_tmp` as well as the parameters `dx`, `dt` and `kappa` as arguments. + +When running `make` again at a later time, the code will only be regenerated if the CMake configuration or the python script have changed. You can force CMake to re-run code generation by deleting the *default_codegen* folder. + +\section walberla_app Including the generated kernel in a waLBerla application + +Finally, we can use the generated sweep in an actual waLBerla application. In the application folder, create the source file *01_CodegenHeatEquation.cpp*. Open *CMakeLists.txt* and register the source file as an executable using the macro `walberla_add_executable`. Add all required waLBerla modules as dependencies, as well as the generated target. + +\code +walberla_add_executable ( NAME 01_CodegenHeatEquation + FILES 01_CodegenHeatEquation.cpp + DEPENDS blockforest core field stencil timeloop vtk pde CodegenHeatEquationKernel ) +\endcode + +Open the source file and include the generated header using `#include "HeatEquationKernel.h"`. The remainder of the application is similar to previous tutorials. We set up a two-dimensional domain by setting the physical size, number of cells and blocks for each direction. The pystencils-generated kernel expects a uniform grid with equal cell sizes in all directions. Therefore, the ratio between side length and the number of cells in each coordinate direction need to be equal. We also set the time step `dt` and the diffusivity coefficient `kappa`. Then, we create the block storage using an axis-aligned bounding box. + +All of the following code snippets are added to the `main` function. + +\code +// Set up the domain +// Ensure matching aspect ratios of cells and domain. +const uint_t xCells = uint_c(25); +const uint_t yCells = uint_c(25); + +const real_t xSize = real_c(1.0); +const real_t ySize = real_c(1.0); + +const uint_t xBlocks = uint_c(1); +const uint_t yBlocks = uint_c(1); + +const real_t dx = xSize / real_c( xBlocks * xCells + uint_t(1) ); +const real_t dy = ySize / real_c( yBlocks * yCells + uint_t(1) ); + +WALBERLA_CHECK_FLOAT_EQUAL(dx, dy); + +const real_t dt = real_c(1e-4); +const real_t kappa = real_c(1.0); + +// Axis-aligned bounding box +auto aabb = math::AABB( real_c(0.5) * dx, real_c(0.5) * dy, real_c(0.0), + xSize - real_c(0.5) * dx, ySize - real_c(0.5) * dy, dx ); + +// Block storage +shared_ptr<StructuredBlockForest> blocks = blockforest::createUniformBlockGrid ( + aabb, + xBlocks, yBlocks, uint_c(1), + xCells, yCells, 1, + true, + false, false, false); +\endcode + +Next, we initialize both the source and destination field and create a communication scheme. Note that we explicitly set the field's memory layouts to `fzyx` to match the layout we specified for the kernel earlier. + +\code +// Fields +BlockDataID uFieldId = field::addToStorage< ScalarField >(blocks, "u", real_c(0.0), field::fzyx, uint_c(1)); +BlockDataID uTmpFieldId = field::addToStorage< ScalarField >(blocks, "u_tmp", real_c(0.0), field::fzyx, uint_c(1)); + +// Communication +blockforest::communication::UniformBufferedScheme< stencil::D2Q9 > commScheme (blocks); +commScheme.addPackInfo( make_shared< field::communication::PackInfo<ScalarField> > ( uFieldId ) ); +\endcode + +Next, let us implement the boundary conditions. We set the north domain border to a Dirichlet boundary: + +\f[ + f(x) = 1 + \sin( 2 \pi x) \cdot x^2. +\f] + +The northern boundary thus models an external heat source with a constant temperature distribution given by \f$ f \f$ touching our two-dimensional plate. During the simulation, this source heats the domain. We implement the Dirichlet boundary as a function which we use to initialize the domain's northernmost ghost layer to the values of \f$ f \f$. Since that ghost layer is never written to during the simulation (if we only use a single socket), we need only initialize it once. For the implementation of the Dirichlet boundary, refer to 01_CodegenHeatEquation.cpp and to \ref setDirichletBC. + +\code +initDirichletBoundaryNorth(blocks, uFieldId, uTmpFieldId); +\endcode + +The remaining three boundaries should be Neumann boundaries imposing a normal gradient of zero, as there is no heat flow across those boundaries. We implement the Neumann boundaries using the walberla::pde::NeumannDomainBoundary class. Its constructor takes our block storage and the velocity field to which we apply the boundary condition. By default, `NeumannDomainBoundary` imposes the boundary condition on all six domain borders. Since a Dirichlet boundary already occupies the northern border and the simulation does not extend into the third dimension, we need to exclude the northern, bottom and top boundaries using `excludeBoundary`. + +\code +pde::NeumannDomainBoundary< ScalarField > neumann(*blocks, uFieldId); + +neumann.excludeBoundary(stencil::N); +neumann.excludeBoundary(stencil::B); +neumann.excludeBoundary(stencil::T); +\endcode + +Last, we need to take care of swapping the source and destination fields after each iteration. We implement this as a function which we pass to the time loop inside a lambda expression. + +As the last step, we set up the time loop. Passing the generated sweep to the `timeloop` is quite straight forward: create an instance of the `HeatEquationKernel` class by passing it the necessary fields and parameters, and pipe it into the `timeloop`. For visualizing the simulation results, we add the VTK output routine as an after-function. We set it to save one snapshot of the distribution every 200 iterations. Also, we call it once to output the initial temperature distribution. + +\code +SweepTimeloop timeloop(blocks, uint_c(2e4)); + +timeloop.add() << BeforeFunction(commScheme, "Communication") << BeforeFunction(neumann, "Neumann Boundaries") + << Sweep(pystencils::HeatEquationKernel(uFieldId, uTmpFieldId, dt, dx, kappa), "HeatEquationKernel") + << AfterFunction([blocks, uFieldId, uTmpFieldId]() { swapFields(*blocks, uFieldId, uTmpFieldId); }, + "Swap"); + +auto vtkWriter = field::createVTKOutput< ScalarField, float >( uFieldId, *blocks, "temperature", uint_c(200), uint_c(0) ); +vtkWriter(); +timeloop.addFuncAfterTimeStep(vtkWriter, "VTK"); + +timeloop.run(); + +return EXIT_SUCCESS; +\endcode + +This completes our application. Below we show the temperature distribution after 20 milliseconds and after 2 seconds of simulated time. + +\image html tutorial_codegen01_paraview.png + +\section codegenOutcome Outcome + +In this tutorial, we used the pystencils framework to discretize the heat equation and describe a numerical solver symbolically. A simulation kernel written in C was generated from the symbolic description. It was embedded in a sweep class generated by the waLBerla build system and the sweep was included in an application to simulate the flow of heat through a plate. + + +\tableofcontents + +*/ + +} \ No newline at end of file diff --git a/apps/tutorials/codegen/CMakeLists.txt b/apps/tutorials/codegen/CMakeLists.txt new file mode 100644 index 000000000..d8234d517 --- /dev/null +++ b/apps/tutorials/codegen/CMakeLists.txt @@ -0,0 +1,11 @@ +# Code Generation Tutorials + +if( WALBERLA_BUILD_WITH_CODEGEN ) + walberla_generate_target_from_python( NAME CodegenHeatEquationKernel + FILE HeatEquationKernel.py + OUT_FILES HeatEquationKernel.cpp HeatEquationKernel.h ) + + walberla_add_executable ( NAME 01_CodegenHeatEquation + FILES 01_CodegenHeatEquation.cpp + DEPENDS blockforest core field stencil timeloop vtk pde CodegenHeatEquationKernel ) +endif() \ No newline at end of file diff --git a/apps/tutorials/codegen/Heat Equation Kernel.ipynb b/apps/tutorials/codegen/Heat Equation Kernel.ipynb new file mode 100644 index 000000000..486e7c248 --- /dev/null +++ b/apps/tutorials/codegen/Heat Equation Kernel.ipynb @@ -0,0 +1,587 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from pystencils.session import *\n", + "import sympy as sp\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "\n", + "sp.init_printing()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Code Generation for the Heat Equation\n", + "\n", + "The <a target=\"_blank\" href=\"https://en.wikipedia.org/wiki/Heat_equation\">heat equation</a> which is a simple partial differential equation describing the flow of heat through a homogenous medium. We can write it as\n", + "$$\n", + " \\frac{\\partial u}{\\partial t} = \n", + " \\kappa \\left( \n", + " \\frac{\\partial^2 u}{\\partial x^2} + \n", + " \\frac{\\partial^2 u}{\\partial y^2}\n", + " \\right)\n", + "$$\n", + "where $\\kappa$ is the medium's diffusion coefficient and $u(x, y, t)$ is the unknown temperature distribution at the coordinate $(x,y)$ at time $t$.\n", + "\n", + "To discretize this equation using pystencils, we first need to define all the fields and other symbols involved." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "u, u_tmp = ps.fields(\"u, u_tmp: [2D]\", layout='fzyx')\n", + "kappa = sp.Symbol(\"kappa\")\n", + "dx = sp.Symbol(\"dx\")\n", + "dt = sp.Symbol(\"dt\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We define the PDE using the pystencils building blocks for transient and spatial derivatives. The definition is implicitly equalled to zero. We use `ps.fd.transient` for a first derivative by time and `ps.fd.diff` to express the second derivatives. `ps.fd.diff` takes a field and a list of spatial dimensions in which the field should be differentiated." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": "-κ⋅(D(D(u[0,0])) + D(D(u[0,0]))) + Transient(u_C)", + "image/png": "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\n", + "text/latex": "$\\displaystyle - \\kappa \\left({\\partial_{0} {\\partial_{0} {{u}_{(0,0)}}}} + {\\partial_{1} {\\partial_{1} {{u}_{(0,0)}}}}\\right) + \\partial_t u_{C}$" + }, + "metadata": {}, + "execution_count": 5 + } + ], + "source": [ + "heat_pde = ps.fd.transient(u) - kappa * ( ps.fd.diff( u, 0, 0 ) + ps.fd.diff( u, 1, 1 ) )\n", + "heat_pde" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Next, the PDE will be discretized. We use the `Discretization2ndOrder` class to apply finite differences discretization to the spatial components, and explicit euler discretization to the transient components. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": " ⎛-2⋅u_C + u_E + u_W -2⋅u_C + u_N + u_S⎞\nu_C + dt⋅κ⋅⎜────────────────── + ──────────────────⎟\n ⎜ 2 2 ⎟\n ⎠dx dx ⎠", + "image/png": "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\n", + "text/latex": "$\\displaystyle {{u}_{(0,0)}} + dt \\kappa \\left(\\frac{- 2 {{u}_{(0,0)}} + {{u}_{(1,0)}} + {{u}_{(-1,0)}}}{dx^{2}} + \\frac{- 2 {{u}_{(0,0)}} + {{u}_{(0,1)}} + {{u}_{(0,-1)}}}{dx^{2}}\\right)$" + }, + "metadata": {}, + "execution_count": 6 + } + ], + "source": [ + "discretize = ps.fd.Discretization2ndOrder(dx=dx, dt=dt)\n", + "heat_pde_discretized = discretize(heat_pde)\n", + "heat_pde_discretized" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "It occurs to us that the right-hand summand can be simplified." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": " 2 \nu_C⋅dx + dt⋅κ⋅(-4⋅u_C + u_E + u_N + u_S + u_W)\n───────────────────────────────────────────────\n 2 \n dx ", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiUAAAAvCAYAAAA8abqkAAAACXBIWXMAAA7EAAAOxAGVKw4bAAAQJElEQVR4Ae2d6ZHVOBeGL1QH0AwZMBnAEMHXZMAMEQAZDMUv5h8FGQARsGQAEwFLBpABTGfQ3/uoLbft60WWr+/mV1VqW/vRo3OtY1l2X7u4uFjZdRP4559/TpX6tMhxqzg+VPx5d6nlpYjHI/X6h46fltd799gETMAETGCIgOaHV/KP+/Jd70t0WiDwQhCfFP5PxfyS/2o2VwTE5r5Cd3S0QXKFxWcmYAImYAJ1AsynH+tR9ZCNkjqPttAjQTyrJLzQ+S3F3a7ELfZUHMJKko691u9iAbnjJmACJmACgYDmiR86ea/j311IbJR0kbmKZ7L9chX0WYPAe4VfNeIcNAETMAETMIE1AjJIXivysY7c0K65k7WYI4pQp1nNeCPPXpB3Co++my8AVqlQB3snvlUjd3W+iT7myq624fqHjvdy60gtV/QTRR49hqltOJ8JmIAJmMBWCHAjy9zMloiaO+qVEk1g3+TvqMdYZL3PsWpUOgLFxBj2T3Rk2Xp0Xx+Vdir/XR7jYQ73RJVi9W7DsSLz2zYachsmYAImYAKzEmDeuM8c1WzlqI0SOqtOx/0gkzZhFhM7+0nY0HneBJkSRhZ53lLZqKPeosJmH4nHIGFz7hyOvkw29oYEU/86nz8OlT2W9Ll051j40A8z6h9N8+nnk5tqruPJiRlzKE8b/mqWPurHN0VnebTA45YsQ4I6VJaJnTdwwmOKIkw8m3bGOKxC/KZdVx+74ie3r77Hjb6z7rcp2mHsssdvcmf3o4K5dGc/ercZKcyon6P59PPJTTXXPHLMHTy+qa22H/1KiTrMakFzBUFRaU6TIgYJz794v/p2MUny2GKu1Yc0weq5uvpI/Id61suQ+sEPaYqj7knGXmLjDyRrTWkTyzmbCZiACZjA/hL4LtH+aIp3QkQxQbEU/7v81+YkoDDP8/f+g2GSEwOCRyysYPyUxxjhjv65fOkq/SXurvxDeco+kMd9Vp44mfNNEibw2rdJlL6TDZdDfVQ6xgKyITN9wpBi/OjTSx2j+1fhtzFOR/LzkTj04HmMj5lbjnA7b4nfWJRk4LFN55s9hcwHr7cbA9ZRkTl1gCmizaefD6lmNMwoJ8fCufL4hn2P+HIuuV6AfKpIJiz2BzCpl07xXPTZkFIWKhN1onjSmPxmcao7aT+B8jEZYzjED53Rn9iX5koJH3B5iVeez/LsAj5TmBUQJudYbqW4G/LXml55tu4kw2AfleeTPEtiYTLX+T3C8qVBonP6iLGGUqwU5pxne5RhSa3JS1FrjjpmWy2STOjUuY59j8j2Vm+hJdmTdJe8M7u95bQnjMxnWAH3ltGw6Os59kTvEGzJXOP8UbMfTjQ4TEhMzDj2IMSMIaKIC5NXjIhHlcVgYQm/nDh0Hid0VipuKsxE3+v6yigN4+GVfOfKhNKYIFkNwCApZVGYc97AOdcxOJ0jc5SRONJ4o4bVEtxv8tX0ELnrP2P6WMjKWLaOm+IxQFaqEwOGvjP5x0cklEtxcKqyTikzJg+v/3bqjtJ2rrd0RnJEXVnTd6UN6u4YIDl5Z+DEbw39YXx4s23Q7TOjGfh06kMXKMnQyVRpx6hDoxl1seuLXxrXPhZdaX2Mesp0jt9IfY3zMnNJ6Xh8U/3mBheb2qMOhbk7b8atis6Eu3ClB6c4JvyfCEaEjmfyH+U7JzqlpZThC3Dhc++hofU/QGIJKE6sMQeyx8cwMe6L8lUnUy6speGiNFYZJjnVwYoDbTddgK/0NgMLGfraHtNH2m3re5SH8cAQYWUsro7EtNQjF9KmARvKql7S/pXnmOpYzQlGlI7oRFjp6Sm8U71FrkLOIX0f0t1aF1XnpnVnk5wwBKNeJ43tATDaJJ+Ua1lzvFOYHpMOjWZUA5YYkN4timsillq2REbNMinjl6qvrfPHiQQ7p1UdudhwoSkndsWxrEJc23I+k2Rz4iDuf/LBqTx34hglfJa9agjELBwHyxT1YJRgeAR5qxXoHGOqJiN5FYf8tVdWFd9cPWgzxFQs36mNNqNjpXhWJWBRPkoZ0cqYPrb2vdIWY/1OntUlGLG/hPEZs2+IcQhGlo41p7pIS7qLrhVUQGWDzhXyNJPLcNEG+Xelt8iyCd0t+8SJ+rNR3VF9jAX1TuakOvjtYDyjx6lurxmpLxvjIyCDfW1CS2GqPFxH+65/tWqVd291KIdRrXOJgQVyTSRzlS2F0VXu8mxQx1Vvqr7G+aNmnFwvm7p8NYe7hvAjLeLDxacQvpI1nJ7ReIzUeZhMFG4aH9SH1brmRpahLS6sNac6ThWBrxkfCjOJr5Reyki46pQWL9Tlagr14av5dn1eyDOmj4GTypV9j33SMY4T1izK81oeA4IyWMHBKW5XDJDvrtpHvtIrLtz5FHH8MKJjdWmrekvDkiNyTNH3Vt2NHdjScRKnHBkPjNEkPiP7moPz4HVoC4wWyTWn0zllRo5fir7GOea8Ks9JJcBFtrmKwDJ/mNgkEBPWOx1Z9idvrSKFYwM6rTmsoGgR1RIUGFOGfS/IUxoQjcqakwN5Q38kL8YV58jC6gB3HfSLOwr6Uy3LxqPOvQzKv0tXlRM51vpY9KWMJ5Pi6D9lYbBmsCiu5pSfsYZPc4yr+aiva/yq+Uadq23aDTpXLaj4/4jXsfmIaxd6i2hdfUfHmvo+pLvUN7ebyilHvkNiNJXPmL7msDwGHZqb0VK55vQ7p8yY8UvR13id5JpZuuvlWWOFQxd/7kz/kGciw/2uuPPL0xU/4FpFRXzbgYa7OtOWn7i2MrRNuzVXyMQkVqYpjkkY+XmTBMfeFyZRJmT8L4WRqdYHxZEGzL1ykou+p/YR2eEXDJiinzwyiuOIwbI26VNILpTRkbGO5yGh5Q+c0I9tOcYL33Q1OSU3474rvUW2ZN1tdmTm8FyccsTeR0Zz8Wnraw4zrgHlNS6ngg2U2XdGOV08Zq45PHLKtOl4Clf0mUUB8pbupDzTmys6f6MMLI3zJgEKyLI+qwp/6/hWPrpTndQqaglX89aUOSaMLFMzICp1cMrdM7Ij5015ZGXyjbLHvS9MxuyZwfhYKT9vELDnhXReJ8ZY6VqJocguXWofkZGx5I2l8DhGx+oeFsYu8iBvdA91wofK7urYlh7zxSNGTnjUpTJNXYh5Jh9VN7LEi/GZwu8V/qxj7NMu9JZ+dfUZvk1979Nd6tqGm8opR8ZDYjSVz5i+5rA8Bh3KYqTf+m0Bqz6y7eLH9bz52+vKG+OPgetqZkaR1ZjxS+GKfbF2g1waJeoUDTaXxhGmLY6BPyUxOpShqIMJ5FuML47NcIgeWYZ6WxUuVfYiX20TmOIwQvbVECnwBQMqeXzgqoIYZWtOaV3xozioHh6lIBOrEmuKtdZwZoTaqI1Xs5pChjYdbYvbiN4ig9odo++dutvsz1zhqZxy5DokRlP5jOxrDs6D16FcRirH/NF63coB2Shz8Fzpz8yMArKR45fClblj7Qb4emht5J8CAI023XNFhFUIEpSP8w90pghzZ920eHvLUK5wtMdnaQ/ZMYnjj8XxBs9cF4uNM5LucXEbrbcIorK71t2t6U4Pp94xWQqjHj6917IOPr1MK4mbuP7tgw7NyaiCK/n0WLgmdzg1Y4e+9o5fpe5ertStvKyAMYfU3LWLi4taRGpAlfK2y9pymeKj0cEjID5bzwfNwkSsI0Lw/QpePS1XJ/rKKG9wytPaXkz3cfsE4njqeGP7ree12KVHiu/UW1pS+qJ0t42T4rjQPJbnZgMePEKrfqdlMYza+IjFSvGdeqS0NT6K62VKnTjlO7jrX5fMih/F6JLAuL9qY3FcxxEKOtXLSAzX9JU2+sYvyqA8vfqqdLYW1L5zFsuuMEpy/LNnz87kX2SWvT+mnNo5lf84pozz5o3rWG4al/fyo8ZzbBubzC9Zs/UWOcb2VfkPUnencFoCI/MZvr5sk1HONULyLe63mclp1PU9havyfJe/1SbP9dI6GXkiS4d9BCxpY20lO+XnLmvsHgQsa+7Q7PaPwEOJ9HT/xGqXKFdvqW1JupvLaSmMzKf991WN3TKjatOp5wc5r+RyTYVSzTfH71l1skrCixite0SzjRIEV6UYCjzC4flQquP11PA4J6WA8tIBPqLV2oGUOpxnPgLFWD7XMS7JztfYhmqWrDl6S+uL0t1MTothZD7DP8htMBqWYj2H5DroeSWT6zqI4ZiN/p4lN4sYtX8QuyZC2/LJ2DiWa8aWSc0/Z92pMjhf0lLtI43V2SGxmlu35q5/W6zn7MecdZvP8O/2GBjl9OEY9I5+71s/huRR+quhPNkbXdesG0eYgAmYgAmYgAmYwAQCkx7fTGjXRU3ABEzABEzABEygRuCallLy3gmuVeOACZiACZiACZiACUwj4Mc30/i5tAmYgAmYgAmYwIYI+PHNhkC6GhMwARMwARMwgWkEbJRM4+fSJmACJmACJmACGyJwsqF6XI0JmIAJ9BLQNwr4nlH80B7fK8DxLyeSv1t0WcR/TcAEjpWAjZJjHVn3ywT2j8CL4qNPQTKd8x9Cv8rzP7LsTMAETGDlxzdWAhMwgUECMiBuy3+V/68wJgbLtGR4pLL8m4no+AowX4zkH3/ZmYAJmMDKKyVWAhMwgUECMhy+KdMdHfmEAP8BNMfxef8vOQVdxgRMYBkEbJQsY5zdSxOYTKCyyjH2H2qGtlX+dUMIjJQfhcHTSHLQBExgiQT8+GaJo+4+m0AegXsqhhExeWOq6uCRzX35O3miuJQJmMAxErBRcoyj6j6ZwDwE2A+StUpSFUcGCW/esJ+Ex0GTDZxq3T43ARM4bAJ+fHPY42fpTWAWAhXD4Yca+CmPMcLqxnP50ikfr/nyb+Bxd+UfymN0PJDHfVaeD5enq1VR7xMdWXWJYY60Y2cCJrBwAjZKFq4A7r4JNAnIQGBF5L08KxnBWNAxbm5trpSUr/kqz98q80YeQwTDg1d+WREJRonCGCvEkRbfuGFfyRN5OxMwARPw2zfWARMwgSsCMhZY+cAgwXCorl5w/k1x5eMWnbNCgtERHWnsE2G1BPebfDWdb5JQP8fSqR4MEzsTMAETsFFiHTABE6gRwIg4laHQfFOG1ZPyMUxR4ovyVQ0XNq2WhovS/izyhYPCN6phn5uACZhAk4A3ujaJOGwCyybwl7pfe0QjY4LVDR69xEc4gZDi+XZJ1VH2bTXC5yZgAiYwhoCNkjG0nNcEjphAYXxggNSMD4UxNlZKrxkrxEWnNFZSKFuuplAfPubx0QRMwASGCHij6xAhp5vA8ghUH8nQe96UCasiMjLYM8L5L3n2nrDRFWOFfSHnOq+WfaqwN7EKjJ0JmEAaAa+UpHFyLhM4egIyIM7VSQwMHtUEpziMEN6U+XIZs7pXGB6sjOB/KcxqCEZK6RRH2ucywicmYAImkEDg2sUF/8rCzgRMwATCIxoMjPBar4435dkjgrHCBliMjE8yONjMSj7ivsuvFH4pjwHDqgpv12CslI9yFLYzARMwgUEC/weXMZOqdFgFVAAAAABJRU5ErkJggg==\n", + "text/latex": "$\\displaystyle \\frac{{{u}_{(0,0)}} dx^{2} + dt \\kappa \\left(- 4 {{u}_{(0,0)}} + {{u}_{(1,0)}} + {{u}_{(0,1)}} + {{u}_{(0,-1)}} + {{u}_{(-1,0)}}\\right)}{dx^{2}}$" + }, + "metadata": {}, + "execution_count": 7 + } + ], + "source": [ + "heat_pde_discretized.simplify()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "While combining the two fractions on the right as desired, it also put everything above a common denominator. If we generated the kernel from this, we'd be redundantly multiplying $u_{(0,0)}$ by $dx^2$. Let's try something else. Instead of applying `simplify` to the entire equation, we could apply it only to the second summand.\n", + "\n", + "The outermost operation of `heat_pde_discretized` is a $+$, so `heat_pde_discretized` is an instance of `sp.Sum`. We take it apart by accessing its arguments, simplify the right hand summand, and put it back together again." + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/latex": [ + "$\\displaystyle {{u}_{(0,0)}} + \\frac{dt \\kappa \\left(- 4 {{u}_{(0,0)}} + {{u}_{(1,0)}} + {{u}_{(0,1)}} + {{u}_{(0,-1)}} + {{u}_{(-1,0)}}\\right)}{dx^{2}}$" + ], + "text/plain": [ + " dt⋅κ⋅(-4⋅u_C + u_E + u_N + u_S + u_W)\n", + "u_C + ─────────────────────────────────────\n", + " 2 \n", + " dx " + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "heat_pde_discretized = heat_pde_discretized.args[1] + heat_pde_discretized.args[0].simplify()\n", + "heat_pde_discretized" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That looks a lot better! There is nothing left to simplify. The right-hand summand still contains a division by $dx^2$, though. Due to their inefficiency, floating-point divisions should be replaced by multiplication with their reciprocals. Before we can eliminate the division, we need to wrap the equation inside an `AssignmentCollection`. On this collection we can apply `add_subexpressions_for_divisions` to replace the division by a factor $\\xi_1 = \\frac{1}{dx^2}$ which in the kernel will be computed ahead of the loop." + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>Subexpressions:</div><table style=\"border:none; width: 100%; \"><tr style=\"border:none\"> <td style=\"border:none\">$$\\xi_{0} \\leftarrow \\frac{1}{dx^{2}}$$</td> </tr> </table><div>Main Assignments:</div><table style=\"border:none; width: 100%; \"><tr style=\"border:none\"> <td style=\"border:none\">$${{u_tmp}_{(0,0)}} \\leftarrow {{u}_{(0,0)}} + dt \\kappa \\xi_{0} \\left(- 4 {{u}_{(0,0)}} + {{u}_{(1,0)}} + {{u}_{(0,1)}} + {{u}_{(0,-1)}} + {{u}_{(-1,0)}}\\right)$$</td> </tr> </table>" + ], + "text/plain": [ + "AssignmentCollection: u_tmp_C, <- f(u_S, u_N, u_E, u_W, dt, u_C, kappa, dx)" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "@ps.kernel\n", + "def update():\n", + " u_tmp.center @= heat_pde_discretized\n", + "\n", + "ac = ps.AssignmentCollection(update)\n", + "ac = ps.simp.simplifications.add_subexpressions_for_divisions(ac)\n", + "ac" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our numeric solver's symbolic representation is now complete! Next, we use pystencils to generate and compile a C implementation of our kernel. The code is generated as shown below, compiled into a shared libary and then bound to `kernel_func`. All unbound sympy symbols (`dx`, `dt` and `kappa`) as well as the fields `u` and `u_tmp` are arguments to the generated kernel function. " + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<style>.highlight .hll { background-color: #ffffcc }\n", + ".highlight { background: #f8f8f8; }\n", + ".highlight .c { color: #408080; font-style: italic } /* Comment */\n", + ".highlight .err { border: 1px solid #FF0000 } /* Error */\n", + ".highlight .k { color: #008000; font-weight: bold } /* Keyword */\n", + ".highlight .o { color: #666666 } /* Operator */\n", + ".highlight .ch { color: #408080; font-style: italic } /* Comment.Hashbang */\n", + ".highlight .cm { color: #408080; font-style: italic } /* Comment.Multiline */\n", + ".highlight .cp { color: #BC7A00 } /* Comment.Preproc */\n", + ".highlight .cpf { color: #408080; font-style: italic } /* Comment.PreprocFile */\n", + ".highlight .c1 { color: #408080; font-style: italic } /* Comment.Single */\n", + ".highlight .cs { color: #408080; font-style: italic } /* Comment.Special */\n", + ".highlight .gd { color: #A00000 } /* Generic.Deleted */\n", + ".highlight .ge { font-style: italic } /* Generic.Emph */\n", + ".highlight .gr { color: #FF0000 } /* Generic.Error */\n", + ".highlight .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n", + ".highlight .gi { color: #00A000 } /* Generic.Inserted */\n", + ".highlight .go { color: #888888 } /* Generic.Output */\n", + ".highlight .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n", + ".highlight .gs { font-weight: bold } /* Generic.Strong */\n", + ".highlight .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n", + ".highlight .gt { color: #0044DD } /* Generic.Traceback */\n", + ".highlight .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n", + ".highlight .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n", + ".highlight .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n", + ".highlight .kp { color: #008000 } /* Keyword.Pseudo */\n", + ".highlight .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n", + ".highlight .kt { color: #B00040 } /* Keyword.Type */\n", + ".highlight .m { color: #666666 } /* Literal.Number */\n", + ".highlight .s { color: #BA2121 } /* Literal.String */\n", + ".highlight .na { color: #7D9029 } /* Name.Attribute */\n", + ".highlight .nb { color: #008000 } /* Name.Builtin */\n", + ".highlight .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n", + ".highlight .no { color: #880000 } /* Name.Constant */\n", + ".highlight .nd { color: #AA22FF } /* Name.Decorator */\n", + ".highlight .ni { color: #999999; font-weight: bold } /* Name.Entity */\n", + ".highlight .ne { color: #D2413A; font-weight: bold } /* Name.Exception */\n", + ".highlight .nf { color: #0000FF } /* Name.Function */\n", + ".highlight .nl { color: #A0A000 } /* Name.Label */\n", + ".highlight .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n", + ".highlight .nt { color: #008000; font-weight: bold } /* Name.Tag */\n", + ".highlight .nv { color: #19177C } /* Name.Variable */\n", + ".highlight .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n", + ".highlight .w { color: #bbbbbb } /* Text.Whitespace */\n", + ".highlight .mb { color: #666666 } /* Literal.Number.Bin */\n", + ".highlight .mf { color: #666666 } /* Literal.Number.Float */\n", + ".highlight .mh { color: #666666 } /* Literal.Number.Hex */\n", + ".highlight .mi { color: #666666 } /* Literal.Number.Integer */\n", + ".highlight .mo { color: #666666 } /* Literal.Number.Oct */\n", + ".highlight .sa { color: #BA2121 } /* Literal.String.Affix */\n", + ".highlight .sb { color: #BA2121 } /* Literal.String.Backtick */\n", + ".highlight .sc { color: #BA2121 } /* Literal.String.Char */\n", + ".highlight .dl { color: #BA2121 } /* Literal.String.Delimiter */\n", + ".highlight .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n", + ".highlight .s2 { color: #BA2121 } /* Literal.String.Double */\n", + ".highlight .se { color: #BB6622; font-weight: bold } /* Literal.String.Escape */\n", + ".highlight .sh { color: #BA2121 } /* Literal.String.Heredoc */\n", + ".highlight .si { color: #BB6688; font-weight: bold } /* Literal.String.Interpol */\n", + ".highlight .sx { color: #008000 } /* Literal.String.Other */\n", + ".highlight .sr { color: #BB6688 } /* Literal.String.Regex */\n", + ".highlight .s1 { color: #BA2121 } /* Literal.String.Single */\n", + ".highlight .ss { color: #19177C } /* Literal.String.Symbol */\n", + ".highlight .bp { color: #008000 } /* Name.Builtin.Pseudo */\n", + ".highlight .fm { color: #0000FF } /* Name.Function.Magic */\n", + ".highlight .vc { color: #19177C } /* Name.Variable.Class */\n", + ".highlight .vg { color: #19177C } /* Name.Variable.Global */\n", + ".highlight .vi { color: #19177C } /* Name.Variable.Instance */\n", + ".highlight .vm { color: #19177C } /* Name.Variable.Magic */\n", + ".highlight .il { color: #666666 } /* Literal.Number.Integer.Long */</style>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<div class=\"highlight\"><pre><span></span><span class=\"n\">FUNC_PREFIX</span> <span class=\"kt\">void</span> <span class=\"nf\">kernel</span><span class=\"p\">(</span><span class=\"kt\">double</span> <span class=\"o\">*</span> <span class=\"n\">RESTRICT</span> <span class=\"k\">const</span> <span class=\"n\">_data_u</span><span class=\"p\">,</span> <span class=\"kt\">double</span> <span class=\"o\">*</span> <span class=\"n\">RESTRICT</span> <span class=\"n\">_data_u_tmp</span><span class=\"p\">,</span> <span class=\"kt\">int64_t</span> <span class=\"k\">const</span> <span class=\"n\">_size_u_0</span><span class=\"p\">,</span> <span class=\"kt\">int64_t</span> <span class=\"k\">const</span> <span class=\"n\">_size_u_1</span><span class=\"p\">,</span> <span class=\"kt\">int64_t</span> <span class=\"k\">const</span> <span class=\"n\">_stride_u_0</span><span class=\"p\">,</span> <span class=\"kt\">int64_t</span> <span class=\"k\">const</span> <span class=\"n\">_stride_u_1</span><span class=\"p\">,</span> <span class=\"kt\">int64_t</span> <span class=\"k\">const</span> <span class=\"n\">_stride_u_tmp_0</span><span class=\"p\">,</span> <span class=\"kt\">int64_t</span> <span class=\"k\">const</span> <span class=\"n\">_stride_u_tmp_1</span><span class=\"p\">,</span> <span class=\"kt\">double</span> <span class=\"n\">dt</span><span class=\"p\">,</span> <span class=\"kt\">double</span> <span class=\"n\">dx</span><span class=\"p\">,</span> <span class=\"kt\">double</span> <span class=\"n\">kappa</span><span class=\"p\">)</span>\n", + "<span class=\"p\">{</span>\n", + " <span class=\"cp\">#pragma omp parallel num_threads(4)</span>\n", + " <span class=\"p\">{</span>\n", + " <span class=\"cp\">#pragma omp for schedule(static)</span>\n", + " <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"kt\">int</span> <span class=\"n\">ctr_1</span> <span class=\"o\">=</span> <span class=\"mi\">1</span><span class=\"p\">;</span> <span class=\"n\">ctr_1</span> <span class=\"o\"><</span> <span class=\"n\">_size_u_1</span> <span class=\"o\">-</span> <span class=\"mi\">1</span><span class=\"p\">;</span> <span class=\"n\">ctr_1</span> <span class=\"o\">+=</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n", + " <span class=\"p\">{</span>\n", + " <span class=\"kt\">double</span> <span class=\"o\">*</span> <span class=\"n\">RESTRICT</span> <span class=\"n\">_data_u_tmp_10</span> <span class=\"o\">=</span> <span class=\"n\">_data_u_tmp</span> <span class=\"o\">+</span> <span class=\"n\">_stride_u_tmp_1</span><span class=\"o\">*</span><span class=\"n\">ctr_1</span><span class=\"p\">;</span>\n", + " <span class=\"kt\">double</span> <span class=\"o\">*</span> <span class=\"n\">RESTRICT</span> <span class=\"n\">_data_u_10</span> <span class=\"o\">=</span> <span class=\"n\">_data_u</span> <span class=\"o\">+</span> <span class=\"n\">_stride_u_1</span><span class=\"o\">*</span><span class=\"n\">ctr_1</span><span class=\"p\">;</span>\n", + " <span class=\"kt\">double</span> <span class=\"o\">*</span> <span class=\"n\">RESTRICT</span> <span class=\"n\">_data_u_11</span> <span class=\"o\">=</span> <span class=\"n\">_data_u</span> <span class=\"o\">+</span> <span class=\"n\">_stride_u_1</span><span class=\"o\">*</span><span class=\"n\">ctr_1</span> <span class=\"o\">+</span> <span class=\"n\">_stride_u_1</span><span class=\"p\">;</span>\n", + " <span class=\"kt\">double</span> <span class=\"o\">*</span> <span class=\"n\">RESTRICT</span> <span class=\"n\">_data_u_1m1</span> <span class=\"o\">=</span> <span class=\"n\">_data_u</span> <span class=\"o\">+</span> <span class=\"n\">_stride_u_1</span><span class=\"o\">*</span><span class=\"n\">ctr_1</span> <span class=\"o\">-</span> <span class=\"n\">_stride_u_1</span><span class=\"p\">;</span>\n", + " <span class=\"k\">for</span> <span class=\"p\">(</span><span class=\"kt\">int</span> <span class=\"n\">ctr_0</span> <span class=\"o\">=</span> <span class=\"mi\">1</span><span class=\"p\">;</span> <span class=\"n\">ctr_0</span> <span class=\"o\"><</span> <span class=\"n\">_size_u_0</span> <span class=\"o\">-</span> <span class=\"mi\">1</span><span class=\"p\">;</span> <span class=\"n\">ctr_0</span> <span class=\"o\">+=</span> <span class=\"mi\">1</span><span class=\"p\">)</span>\n", + " <span class=\"p\">{</span>\n", + " <span class=\"n\">_data_u_tmp_10</span><span class=\"p\">[</span><span class=\"n\">_stride_u_tmp_0</span><span class=\"o\">*</span><span class=\"n\">ctr_0</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"n\">dt</span><span class=\"o\">*</span><span class=\"n\">kappa</span><span class=\"o\">*</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"mf\">4.0</span><span class=\"o\">*</span><span class=\"n\">_data_u_10</span><span class=\"p\">[</span><span class=\"n\">_stride_u_0</span><span class=\"o\">*</span><span class=\"n\">ctr_0</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">_data_u_10</span><span class=\"p\">[</span><span class=\"n\">_stride_u_0</span><span class=\"o\">*</span><span class=\"n\">ctr_0</span> <span class=\"o\">+</span> <span class=\"n\">_stride_u_0</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">_data_u_10</span><span class=\"p\">[</span><span class=\"n\">_stride_u_0</span><span class=\"o\">*</span><span class=\"n\">ctr_0</span> <span class=\"o\">-</span> <span class=\"n\">_stride_u_0</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">_data_u_11</span><span class=\"p\">[</span><span class=\"n\">_stride_u_0</span><span class=\"o\">*</span><span class=\"n\">ctr_0</span><span class=\"p\">]</span> <span class=\"o\">+</span> <span class=\"n\">_data_u_1m1</span><span class=\"p\">[</span><span class=\"n\">_stride_u_0</span><span class=\"o\">*</span><span class=\"n\">ctr_0</span><span class=\"p\">])</span><span class=\"o\">/</span><span class=\"p\">(</span><span class=\"n\">dx</span><span class=\"o\">*</span><span class=\"n\">dx</span><span class=\"p\">)</span> <span class=\"o\">+</span> <span class=\"n\">_data_u_10</span><span class=\"p\">[</span><span class=\"n\">_stride_u_0</span><span class=\"o\">*</span><span class=\"n\">ctr_0</span><span class=\"p\">];</span>\n", + " <span class=\"p\">}</span>\n", + " <span class=\"p\">}</span>\n", + " <span class=\"p\">}</span>\n", + "<span class=\"p\">}</span>\n", + "</pre></div>\n" + ], + "text/plain": [ + "FUNC_PREFIX void kernel(double * RESTRICT const _data_u, double * RESTRICT _data_u_tmp, int64_t const _size_u_0, int64_t const _size_u_1, int64_t const _stride_u_0, int64_t const _stride_u_1, int64_t const _stride_u_tmp_0, int64_t const _stride_u_tmp_1, double dt, double dx, double kappa)\n", + "{\n", + " #pragma omp parallel num_threads(4)\n", + " {\n", + " #pragma omp for schedule(static)\n", + " for (int ctr_1 = 1; ctr_1 < _size_u_1 - 1; ctr_1 += 1)\n", + " {\n", + " double * RESTRICT _data_u_tmp_10 = _data_u_tmp + _stride_u_tmp_1*ctr_1;\n", + " double * RESTRICT _data_u_10 = _data_u + _stride_u_1*ctr_1;\n", + " double * RESTRICT _data_u_11 = _data_u + _stride_u_1*ctr_1 + _stride_u_1;\n", + " double * RESTRICT _data_u_1m1 = _data_u + _stride_u_1*ctr_1 - _stride_u_1;\n", + " for (int ctr_0 = 1; ctr_0 < _size_u_0 - 1; ctr_0 += 1)\n", + " {\n", + " _data_u_tmp_10[_stride_u_tmp_0*ctr_0] = dt*kappa*(-4.0*_data_u_10[_stride_u_0*ctr_0] + _data_u_10[_stride_u_0*ctr_0 + _stride_u_0] + _data_u_10[_stride_u_0*ctr_0 - _stride_u_0] + _data_u_11[_stride_u_0*ctr_0] + _data_u_1m1[_stride_u_0*ctr_0])/(dx*dx) + _data_u_10[_stride_u_0*ctr_0];\n", + " }\n", + " }\n", + " }\n", + "}" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "kernel_ast = ps.create_kernel(update, cpu_openmp = 4)\n", + "kernel_func = kernel_ast.compile()\n", + "\n", + "ps.show_code(kernel_ast)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Prototype Simulation\n", + "\n", + "We can set up and run a simple simulation wich the generated kernel right here. The first step is to set up the fields and simulation parameters." + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "domain_size = 1.0\n", + "cells = 25\n", + "delta_x = domain_size / cells\n", + "\n", + "delta_t = 0.0001\n", + "kappa_v = 1.0\n", + "\n", + "u = np.zeros((cells, cells))\n", + "u_tmp = np.zeros_like(u)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also need the Dirichlet and Neumann Boundaries." + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "def f(x):\n", + " return (1 + np.sin(2 * np.pi * x) * x**2)\n", + "\n", + "def init_domain(domain, domain_tmp):\n", + " domain.fill(0)\n", + " domain_tmp.fill(0)\n", + " domain[:,-1] = f( np.linspace(0, 1, domain.shape[0]) )\n", + " domain_tmp[:,-1] = f( np.linspace(0, 1, domain_tmp.shape[0]) )\n", + " return domain, domain_tmp\n", + "\n", + "def neumann(domain):\n", + " domain[0,:] = domain[1, :]\n", + " domain[-1,:] = domain[-2,:]\n", + " domain[:,0] = domain[:,1]\n", + " return domain" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "After application of the Dirichlet boundary condition, this is our initial situation. In waLBerla, the domain edges would be ghost layers." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<mpl_toolkits.mplot3d.art3d.Poly3DCollection at 0x7ffb64712510>" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "<Figure size 1152x432 with 1 Axes>" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "init_domain(u, u_tmp)\n", + "\n", + "ps.plot.scalar_field_surface(u)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, define the loop function." + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "def loop(steps = 5):\n", + " global u, u_tmp\n", + " for _ in range(steps):\n", + " neumann(u)\n", + " kernel_func(u=u, u_tmp=u_tmp, dx=delta_x, dt=delta_t, kappa=kappa_v)\n", + " u, u_tmp = u_tmp, u\n", + "\n", + " return u" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAABkAAAAOCAYAAADaOrdAAAAACXBIWXMAAA7EAAAOxAGVKw4bAAABoklEQVQ4EZWUMVLDMBBFHcgBMuYGSUsFpPcM5gbAEeAIKeM2lHShpGNISUcKF0kF+AYxJwjxDcz7GssTZNnAzuysdvdrv6SV1CvLMkiSZBgEwQSVnKFf6IR4psBfBOyswm2xI3RGLFfsEBXBnMB1FEUv6EOapsfEHrFrfAPEbxXmfpB8wt6DXzNvhb/Cqt7uAEcruEVrAaxdFehzHWwZgL0hNcAuLISx5sqfKyaSGN2QGCiwJ0vGmqyddskVSd+xvhGPVVckKpZX7Awb4pK7AC1SPXTFHnPcp7hW4pMTBcn7Vmnw5H5bgHChdtIQJotAx2RvXANTBcLKqgdtYo7Ll1TDF5Dd+ZL/jB01dkJh3Qj1qO0Y9zl8vbB5u8vtDxIK6zqG2AuL7LLg7DH5emNjeU3ChEsKjrD1DhgPpV1E5HQ7fRi7k6UhoZAaPca6jRZx15GQNg9WX5ErpwQyaha96XSqVbyiWpErekz6hwKstr9DNVEFasHf4OivM6++wn4SO2ec9RmIQETqhyv1GwFcoHpg7y4IX6T6EMdYfZCyhgAbfAMYcZVxKCASawAAAABJRU5ErkJggg==\n", + "text/latex": [ + "$\\displaystyle 2.0$" + ], + "text/plain": [ + "2.0" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "200 * 100 * delta_t" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Not only can we run the kernel, we can even view the results as a video! This is a useful tool for debugging and testing the solver before introducing it into a larger application. We can view the simulation animated both as a colorful 2D plot or as a 3D surface plot.\n", + "\n", + "The total time interval being simulated is two seconds (100 frames à 200 steps à 0.1 milliseconds)." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<video controls width=\"80%\">\n", + " <source src=\"data:video/x-m4v;base64,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\" type=\"video/mp4\">\n", + " Your browser does not support the video tag.\n", + "</video>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "init_domain(u, u_tmp)\n", + "\n", + "anim = ps.plot.scalar_field_animation(lambda : loop(200), frames = 100, rescale = False)\n", + "result = ps.jupyter.display_as_html_video(anim)\n", + "result" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<video controls width=\"80%\">\n", + " <source src=\"data:video/x-m4v;base64,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\" type=\"video/mp4\">\n", + " Your browser does not support the video tag.\n", + "</video>" + ], + "text/plain": [ + "<IPython.core.display.HTML object>" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "init_domain(u, u_tmp)\n", + "\n", + "anim = ps.plot.surface_plot_animation(lambda : loop(200), frames = 100)\n", + "result = ps.jupyter.display_as_html_video(anim)\n", + "result" + ] + } + ], + "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.8.2" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/apps/tutorials/codegen/HeatEquationKernel.py b/apps/tutorials/codegen/HeatEquationKernel.py new file mode 100644 index 000000000..2aefdba6d --- /dev/null +++ b/apps/tutorials/codegen/HeatEquationKernel.py @@ -0,0 +1,25 @@ +import sympy as sp +import pystencils as ps +from pystencils_walberla import CodeGeneration, generate_sweep + +u, u_tmp = ps.fields("u, u_tmp: [2D]", layout='fzyx') +kappa = sp.Symbol("kappa") +dx = sp.Symbol("dx") +dt = sp.Symbol("dt") +heat_pde = ps.fd.transient(u) - kappa * (ps.fd.diff(u, 0, 0) + ps.fd.diff(u, 1, 1)) + +discretize = ps.fd.Discretization2ndOrder(dx=dx, dt=dt) +heat_pde_discretized = discretize(heat_pde) +heat_pde_discretized = heat_pde_discretized.args[1] + heat_pde_discretized.args[0].simplify() + + +@ps.kernel +def update(): + u_tmp.center @= heat_pde_discretized + + +ac = ps.AssignmentCollection(update) +ac = ps.simp.simplifications.add_subexpressions_for_divisions(ac) + +with CodeGeneration() as ctx: + generate_sweep(ctx, 'HeatEquationKernel', ac) diff --git a/doc/Mainpage.dox b/doc/Mainpage.dox index d917271aa..ed13b558e 100644 --- a/doc/Mainpage.dox +++ b/doc/Mainpage.dox @@ -42,6 +42,11 @@ all the basic data strcutures and concepts of the framework. A full LBM simulation is built. - \ref tutorial_lbm04 \n A LBM simulation with complex geometries is built. + +\subsection codegen Code Generation with pystencils + +- \ref tutorial_codegen01 \n + This tutorial shows how to use pystencils to generate waLBerla sweeps from symbolic descriptions. \section further_info Further information diff --git a/doc/pics/tutorial_codegen01_paraview.png b/doc/pics/tutorial_codegen01_paraview.png new file mode 100644 index 0000000000000000000000000000000000000000..974339f790da424f14ff59df779a62fbf51e61e1 GIT binary patch literal 110061 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 literal 0 HcmV?d00001 -- GitLab