Adaptive Volume Integral

NEWS.md

@@ -37,10 +37,11 @@ for human readability.
 ## Changes in the v0.13 lifecycle
 
 #### Added
-- Initial 3D support for subcell limiting with `P4estMesh` was added ([#2582], [#2647], [#2688], [#2722]).
+- Initial 3D support for subcell limiting with `P4estMesh` was added ([#2582] and [#2647]).
   In the new version, IDP positivity limiting for conservative variables (using
   the keyword `positivity_variables_cons` in `SubcellLimiterIDP()`) and nonlinear
   variables (using `positivity_variables_nonlinear`) is supported.
+  `BoundsCheckCallback` is not supported in 3D yet.
 - Optimized 2D and 3D kernels for nonconservative fluxes with `P4estMesh` were added ([#2653], [#2663]).
   The optimized kernel can be enabled via the trait `Trixi.combine_conservative_and_nonconservative_fluxes(flux, equations)`.
   When the trait is set to `Trixi.True()`, a single method has to be defined, that computes and returns the tuple

benchmark/Project.toml

@@ -8,4 +8,4 @@ Trixi = "a7f1ee26-1774-49b1-8366-f1abc58fbfcb"
 BenchmarkTools = "0.5, 0.7, 1.0"
 OrdinaryDiffEq = "5.65, 6"
 PkgBenchmark = "0.2.10"
-Trixi = "0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.10, 0.11, 0.12, 0.13, 0.14"
+Trixi = "0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.10, 0.11, 0.12, 0.13"

docs/literate/src/files/adding_nonconservative_equation.jl

@@ -82,9 +82,9 @@ end
 # The implementation of nonconservative terms uses a single "nonconservative flux"
 # function `flux_nonconservative`. It will basically be applied in a loop of the
 # form
-# ````julia
+# ```julia
 # du_m(D, u) = sum(D[m, l] * flux_nonconservative(u[m], u[l], 1, equations)) # orientation 1: x
-# ````
+# ```
 # where `D` is the derivative matrix and `u` contains the nodal solution values.
 
 # Now, we can run a simple simulation using a DGSEM discretization.

docs/literate/src/files/first_steps/changing_trixi.jl

@@ -37,10 +37,10 @@
 #   julia --project=.
 #   ```
 # - Now run the following commands to install all relevant packages:
-#   ````julia
+#   ```julia
 #   using Pkg; Pkg.develop(PackageSpec(path="..")) # Tell Julia to use the local Trixi.jl clone
 #   Pkg.add(["OrdinaryDiffEqLowStorageRK", "OrdinaryDiffEqSSPRK", "Plots"]) # Install additional packages
-#   ````
+#   ```
 
 # Now you already installed Trixi.jl from your local clone. Note that if you installed Trixi.jl
 # this way, you always have to start Julia with the `--project` flag set to your `run` directory,

docs/literate/src/files/first_steps/create_first_setup.jl

@@ -78,9 +78,9 @@ solver = DGSEM(polydeg = 3)
 # initial conditions for [`LinearScalarAdvectionEquation2D`](@ref) can be found in
 # [`src/equations/linear_scalar_advection_2d.jl`](https://github.com/trixi-framework/Trixi.jl/blob/main/src/equations/linear_scalar_advection_2d.jl).
 # If you want to use, for example, a Gaussian pulse, it can be used as follows:
-# ````julia
+# ```julia
 # initial_conditions = initial_condition_gauss
-# ````
+# ```
 # But to show you how an arbitrary initial condition can be implemented in a way suitable for
 # Trixi.jl, we define our own initial conditions.
 # ```math
@@ -215,9 +215,9 @@ using Plots
 
 # As was shown in the [Getting started](@ref getting_started) section, you can plot all
 # variables from the system of equations by executing the following.
-# ````julia
+# ```julia
 # plot(sol)
-# ````
+# ```
 # Alternatively, you can configure the plot more precisely. Trixi.jl provides a special data type,
 # [`PlotData2D`](@ref), to extract the visualization data from the solution.
 
@@ -250,10 +250,10 @@ plot!(getmesh(pd))
 # [ParaView](https://www.paraview.org) or [VisIt](https://visit.llnl.gov) to plot the solution.
 
 # If you haven't added Trixi2Vtk.jl to your project yet, you can add it as follows.
-# ````julia
+# ```julia
 # import Pkg
 # Pkg.add(["Trixi2Vtk"])
-# ````
+# ```
 # Now we load the Trixi2Vtk.jl package and convert the file `out/solution_000000032.h5` with
 # the final solution using the [`trixi2vtk`](@ref) function saving the resulting file in the
 # `out` folder.

docs/literate/src/files/first_steps/getting_started.jl

@@ -69,10 +69,10 @@
 # - Execute the following commands to install all mentioned packages. Please note that the
 #   installation process involves downloading and precompiling the source code, which may take
 #   some time depending on your machine.
-#   ````julia
+#   ```julia
 #   import Pkg
 #   Pkg.add(["OrdinaryDiffEqLowStorageRK", "OrdinaryDiffEqSSPRK", "Plots", "Trixi"])
-#   ````
+#   ```
 # - On Windows, the firewall may request permission to install packages.
 
 # Besides Trixi.jl you have now installed additional packages:
@@ -136,10 +136,10 @@
 
 # Start Julia in a terminal and execute the following code:
 
-# ````julia
+# ```julia
 # using Trixi, OrdinaryDiffEq
 # trixi_include(joinpath(examples_dir(), "tree_2d_dgsem", "elixir_euler_ec.jl"))
-# ````
+# ```
 using Trixi, OrdinaryDiffEqLowStorageRK #hide #md
 trixi_include(@__MODULE__, joinpath(examples_dir(), "tree_2d_dgsem", "elixir_euler_ec.jl")); #hide #md
 
@@ -190,14 +190,14 @@ get_examples()
 
 # - Open the downloaded file `elixir_euler_ec.jl` with a text editor.
 # - Go to the line with the following code:
-#   ````julia
+#   ```julia
 #   initial_condition = initial_condition_weak_blast_wave
-#   ````
+#   ```
 #   Here, [`initial_condition_weak_blast_wave`](@ref) is used as the initial condition.
 # - Comment out the line using the `#` symbol:
-#   ````julia
+#   ```julia
 #   # initial_condition = initial_condition_weak_blast_wave
-#   ````
+#   ```
 # - Now you can create your own initial conditions. Add the following code after the
 #   commented line:
 
@@ -214,12 +214,12 @@ nothing; #hide #md
 
 # - Execute the following code one more time, but instead of `path/to/file` paste the path to the
 #   `elixir_euler_ec.jl` file that you just edited.
-#   ````julia
+#   ```julia
 #   using Trixi
 #   trixi_include(path/to/file);
 #   using Plots
 #   plot(sol)
-#   ````
+#   ```
 # Then you will obtain a new solution from running the simulation with a different initial
 # condition.
 
@@ -233,14 +233,14 @@ p4 = plot(pd["p"], clim = (10, 30)) #hide #md
 plot(p1, p2, p3, p4) #hide #md
 
 # To get exactly the same picture execute the following.
-# ````julia
+# ```julia
 # pd = PlotData2D(sol)
 # p1 = plot(pd["rho"])
 # p2 = plot(pd["v1"], clim=(0.05, 0.15))
 # p3 = plot(pd["v2"], clim=(0.15, 0.25))
 # p4 = plot(pd["p"], clim=(10, 30))
 # plot(p1, p2, p3, p4)
-# ````
+# ```
 
 # Feel free to make further changes to the initial condition to observe different solutions.
 

docs/literate/src/files/hohqmesh_tutorial.jl

@@ -24,9 +24,9 @@
 # [HOHQMesh.jl](https://github.com/trixi-framework/HOHQMesh.jl).
 # This package provides a Julia wrapper for the HOHQMesh generator that allows users to easily create mesh
 # files without the need to build HOHQMesh from source. To install the HOHQMesh package execute
-# ````julia
+# ```julia
 # import Pkg; Pkg.add("HOHQMesh")
-# ````
+# ```
 # Now we are ready to generate an unstructured quadrilateral mesh that can be used by Trixi.jl.
 
 # ## Running and visualizing an unstructured simulation
@@ -289,12 +289,12 @@ output = generate_mesh(control_file);
 # To construct the unstructured quadrilateral mesh from the HOHQMesh file we point to the appropriate location
 # with the variable `mesh_file` and then feed this into the constructor for the [`UnstructuredMesh2D`](@ref) type in Trixi.jl
 
-# ````julia
+# ```julia
 # # create the unstructured mesh from your mesh file
 # using Trixi
 # mesh_file = joinpath("out", "ice_cream_straight_sides.mesh")
 # mesh = UnstructuredMesh2D(mesh_file);
-# ````
+# ```
 
 # The complete elixir file for this simulation example is given below.
 
@@ -523,25 +523,25 @@ mesh = UnstructuredMesh2D(mesh_file);
 # As described above, the first block of the HOHQMesh control file contains the parameter
 # `mesh file format`. If you set `mesh file format = ABAQUS` instead of `ISM-V2`,
 # HOHQMesh.jl's function `generate_mesh` creates an Abaqus mesh file `.inp`.
-# ````julia
+# ```julia
 # using HOHQMesh
 # control_file = joinpath("out", "ice_cream_straight_sides.control")
 # output = generate_mesh(control_file);
-# ````
+# ```
 
 # Now, you can create a `P4estMesh` from your mesh file. It is described in detail in the
 # [P4est-based mesh](https://trixi-framework.github.io/TrixiDocumentation/stable/meshes/p4est_mesh/#P4est-based-mesh)
 # part of the Trixi.jl docs.
-# ````julia
+# ```julia
 # using Trixi
 # mesh_file = joinpath("out", "ice_cream_straight_sides.inp")
 # mesh = P4estMesh{2}(mesh_file)
-# ````
+# ```
 
 # Since `P4estMesh` supports AMR, we just have to extend the setup from the first example by the
 # standard AMR procedure. For more information about AMR in Trixi.jl, see the [matching tutorial](@ref adaptive_mesh_refinement).
 
-# ````julia
+# ```julia
 # amr_indicator = IndicatorLöhner(semi, variable=density)
 
 # amr_controller = ControllerThreeLevel(semi, amr_indicator,
@@ -555,7 +555,7 @@ mesh = UnstructuredMesh2D(mesh_file);
 #                            adapt_initial_condition_only_refine=true)
 
 # callbacks = CallbackSet(..., amr_callback)
-# ````
+# ```
 
 # We can then post-process the solution file at the final time on the new mesh with `Trixi2Vtk` and visualize
 # with ParaView, see the appropriate [visualization section](https://trixi-framework.github.io/TrixiDocumentation/stable/visualization/#Trixi2Vtk)

docs/literate/src/files/non_periodic_boundaries.jl

@@ -2,9 +2,9 @@
 
 # # Dirichlet boundary condition
 # First, let's look at the Dirichlet boundary condition [`BoundaryConditionDirichlet`](@ref).
-# ````julia
+# ```julia
 # BoundaryConditionDirichlet(boundary_value_function)
-# ````
+# ```
 # In Trixi.jl, this creates a Dirichlet boundary condition where the function `boundary_value_function`
 # is used to set the values at the boundary. It can be used to create a boundary condition that sets
 # exact boundary values by passing the exact solution of the equation.
@@ -21,9 +21,9 @@
 
 # The passed boundary value function is called with the same arguments as an initial condition
 # function, i.e.
-# ````julia
+# ```julia
 # boundary_value_function(x, t, equations)
-# ````
+# ```
 # where `x` specifies the spatial coordinates, `t` is the current time, and `equations` is the
 # corresponding system of equations.
 

docs/literate/src/files/p4est_from_gmsh.jl

@@ -20,12 +20,12 @@ trixi_include(joinpath(examples_dir(), "p4est_2d_dgsem",
                        "elixir_euler_NACA6412airfoil_mach2.jl"), tspan = (0.0, 0.5))
 
 # Conveniently, we use the Plots package to have a first look at the results:
-# ````julia
+# ```julia
 # using Plots
 # pd = PlotData2D(sol)
 # plot(pd["rho"])
 # plot!(getmesh(pd))
-# ````
+# ```
 
 # ## Creating a mesh using `gmsh`
 
@@ -403,14 +403,14 @@ trixi_include(joinpath(examples_dir(), "p4est_2d_dgsem",
 # This is followed by the nodesets encoded via `*NSET` which are used to assign boundary conditions in Trixi.jl.
 # Trixi.jl parses the `.inp` file and assigns the edges (in 2D, surfaces in 3D) of elements to the corresponding boundary condition based on
 # the supplied `boundary_symbols` that have to be supplied to the `P4estMesh` constructor:
-# ````julia
+# ```julia
 # # boundary symbols
 # boundary_symbols = [:PhysicalLine1, :PhysicalLine2, :PhysicalLine3, :PhysicalLine4]
 # mesh = P4estMesh{2}(mesh_file, polydeg = polydeg, boundary_symbols = boundary_symbols)
-# ````
+# ```
 # The same boundary symbols have then also be supplied to the semidiscretization alongside the
 # corresponding physical boundary conditions:
-# ````julia
+# ```julia
 # # Supersonic inflow boundary condition.
 # # Calculate the boundary flux entirely from the external solution state, i.e., set
 # # external solution state values for everything entering the domain.
@@ -441,7 +441,7 @@ trixi_include(joinpath(examples_dir(), "p4est_2d_dgsem",
 #
 # semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver,
 #                                     boundary_conditions = boundary_conditions)
-# ````
+# ```
 # Note that you **have to** supply the `boundary_symbols` keyword to the `P4estMesh` constructor
 # to select the boundaries from the available nodesets in the `.inp` file.
 # If the `boundary_symbols` keyword is not supplied, all boundaries will be assigned to the default set `:all`.

docs/literate/src/files/shock_capturing.jl

@@ -12,10 +12,9 @@
 # [Hennemann et al. (2021)](https://doi.org/10.1016/j.jcp.2020.109935). In
 # [Rueda-Ramírez et al. (2021)](https://doi.org/10.1016/j.jcp.2021.110580) you find the extension to
 # the systems with non-conservative terms, such as the compressible magnetohydrodynamics (MHD) equations.
-# Furthermore, the latter paper introduces also second-order subcell finite volume stabilization.
 
 # The strategy for a shock-capturing method presented by Hennemann et al. is based on a hybrid blending
-# of a high-order DG method with a low-order variant. The low-order subcell first order finite volume (FV) method is created
+# of a high-order DG method with a low-order variant. The low-order subcell finite volume (FV) method is created
 # directly with the Legendre-Gauss-Lobatto (LGL) nodes already used for the high-order DGSEM.
 # Then, the final method is a convex combination with regulating indicator $\alpha$ of these two methods.
 
@@ -36,19 +35,7 @@
 #                                                  volume_flux_fv=volume_flux_fv)
 # ````
 
-# The volume integral employing second-order FV stabilization is constructed similarly:
-# ````julia
-# volume_integral = VolumeIntegralShockCapturingRRG(basis, indicator_sc;
-#                                                   volume_flux_dg=flux_central,
-#                                                   volume_flux_fv=flux_lax_friedrichs,
-#                                                   slope_limiter=minmod)
-# ````
-# In addition to the parameters of the HG method, the DG `basis` **must** be supplied here.
-# The `slope_limiter` keyword argument is optional and defaults to `minmod`.
-# A list of supported slope limiters can be found in the reference of [`VolumeIntegralShockCapturingRRG`](@ref).
-
-# We now focus on a choice of the shock capturing indicator `indicator_sc`, which can be used for both
-# the first-order and the second-order FV stabilization.
+# We now focus on a choice of the shock capturing indicator `indicator_sc`.
 # A possible indicator is $\alpha_{HG}$ presented by Hennemann et al. (p.10), which depends on the
 # current approximation with modal coefficients $\{m_j\}_{j=0}^N$ of a given `variable`.
 
@@ -268,9 +255,9 @@ plot(sol)
 # The default value for the corresponding parameter $c=$ `exp_entropy_decrease_max` is set to $-10^{-13}$, i.e., slightly less than zero to
 # avoid spurious limiter actions for cells in which the entropy remains effectively constant.
 # Other values can be specified by setting the `exp_entropy_decrease_max` keyword in the constructor of the limiter:
-# ````julia
+# ```julia
 # stage_limiter! = EntropyBoundedLimiter(exp_entropy_decrease_max=-1e-9)
-# ````
+# ```
 # Smaller values (larger in absolute value) for `exp_entropy_decrease_max` relax the entropy increase requirement and are thus less diffusive.
 # On the other hand, for larger values (smaller in absolute value) of `exp_entropy_decrease_max` the limiter acts more often and the solution becomes more diffusive.
 #

docs/literate/src/files/structured_mesh_mapping.jl

@@ -186,13 +186,13 @@ plot!(getmesh(pd))
 # Moreover, the plot shows the mesh structure resulting from our transformation mapping.
 
 # Of course, you can also use other mappings as for instance shifts by $(x, y)$
-# ````julia
+# ```julia
 # mapping(xi, eta) = SVector(xi + x, eta + y)
-# ````
+# ```
 # or rotations with a rotation matrix $T$
-# ````julia
+# ```julia
 # mapping(xi, eta) = T * SVector(xi, eta).
-# ````
+# ```
 
 # For more curved mesh mappings, please have a look at some
 # [elixirs for `StructuredMesh`](https://github.com/trixi-framework/Trixi.jl/tree/main/examples).