From 7b94af2fc714d62c82969bdff5704bc5d9f917cb Mon Sep 17 00:00:00 2001
From: Marco Artiano <artianomarco97@gmail.com>
Date: Thu, 30 May 2024 17:08:00 +0200
Subject: [PATCH 01/13] first draft IMEX JinXin

---
 src/time_integration/methods_IMEXJinXin.jl | 575 +++++++++++++++++++++
 src/time_integration/time_integration.jl   |   1 +
 2 files changed, 576 insertions(+)
 create mode 100644 src/time_integration/methods_IMEXJinXin.jl

diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
new file mode 100644
index 0000000000..30c1b8252e
--- /dev/null
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -0,0 +1,575 @@
+# By default, Julia/LLVM does not use fused multiply-add operations (FMAs).
+# Since these FMAs can increase the performance of many numerical algorithms,
+# we need to opt-in explicitly.
+# See https://ranocha.de/blog/Optimizing_EC_Trixi for further details.
+@muladd begin
+#! format: noindent
+
+# Abstract base type for time integration schemes of explicit strong stability-preserving (SSP)
+# Runge-Kutta (RK) methods. They are high-order time discretizations that guarantee the TVD property.
+abstract type SimpleAlgorithmIMEX end
+
+"""
+    SimpleIMEX(; stage_callbacks=())
+
+    Pareschi - Russo IMEX Explicit Implicit IMEX-SSP2(3,3,2) Stiffly Accurate Scheme
+
+## References
+
+- missing
+
+!!! warning "Experimental implementation"
+    This is an experimental feature and may change in future releases.
+"""
+struct SimpleIMEX{StageCallbacks} <: SimpleAlgorithmIMEX
+    A1::Matrix{Float64}
+    A2::Matrix{Float64}
+    b::SVector{3, Float64}
+    c1::SVector{3, Float64}
+    c2::SVector{3, Float64}
+    stage_callbacks::StageCallbacks
+
+    function SimpleIMEX(; stage_callbacks = ())
+        # Mathematically speaking, it is not necessary for the algorithm to split the factors
+        # into numerator and denominator. Otherwise, however, rounding errors of the order of
+        # the machine accuracy will occur, which will add up over time and thus endanger the
+        # conservation of the simulation.
+        # See also https://github.com/trixi-framework/Trixi.jl/pull/1640.
+        A1 = zeros(3,3)
+        A2 = zeros(3,3)
+        A1[2,1] = 0.5
+        A1[3,1] = 0.5
+        A1[3,2] = 0.5
+
+        A2[1,1] = 1/4
+        A2[2,2] = 1/4
+        A2[3,1] = 1/3
+        A2[3,2] = 1/3
+        A2[3,3] = 1/3
+
+        b = SVector(1/3, 1/3, 1/3) 
+        c1 = SVector(0.0, 1/2, 1)
+        c2 = SVector(1/4, 1/4, 1)
+
+        # Butcher tableau
+        #   c |       a
+        #   0 |
+        #   1 |   1
+        # 1/2 | 1/4  1/4
+        # --------------------
+        #   b | 1/6  1/6  2/3
+
+        new{typeof(stage_callbacks)}(A1, A2, b, c1,c2,
+                                     stage_callbacks)
+    end
+end
+
+# This struct is needed to fake https://github.com/SciML/OrdinaryDiffEq.jl/blob/0c2048a502101647ac35faabd80da8a5645beac7/src/integrators/type.jl#L1
+mutable struct SimpleIntegratorIMEXOptions{Callback, TStops}
+    callback::Callback # callbacks; used in Trixi
+    adaptive::Bool # whether the algorithm is adaptive; ignored
+    dtmax::Float64 # ignored
+    maxiters::Int # maximal number of time steps
+    tstops::TStops # tstops from https://diffeq.sciml.ai/v6.8/basics/common_solver_opts/#Output-Control-1; ignored
+end
+
+function SimpleIntegratorIMEXOptions(callback, tspan; maxiters = typemax(Int), kwargs...)
+    tstops_internal = BinaryHeap{eltype(tspan)}(FasterForward())
+    # We add last(tspan) to make sure that the time integration stops at the end time
+    push!(tstops_internal, last(tspan))
+    # We add 2 * last(tspan) because add_tstop!(integrator, t) is only called by DiffEqCallbacks.jl if tstops contains a time that is larger than t
+    # (https://github.com/SciML/DiffEqCallbacks.jl/blob/025dfe99029bd0f30a2e027582744528eb92cd24/src/iterative_and_periodic.jl#L92)
+    push!(tstops_internal, 2 * last(tspan))
+    SimpleIntegratorIMEXOptions{typeof(callback), typeof(tstops_internal)}(callback,
+                                                                          false, Inf,
+                                                                          maxiters,
+                                                                          tstops_internal)
+end
+
+# This struct is needed to fake https://github.com/SciML/OrdinaryDiffEq.jl/blob/0c2048a502101647ac35faabd80da8a5645beac7/src/integrators/type.jl#L77
+# This implements the interface components described at
+# https://diffeq.sciml.ai/v6.8/basics/integrator/#Handing-Integrators-1
+# which are used in Trixi.
+mutable struct SimpleIntegratorIMEX{RealT <: Real, uType, Params, Sol, F, Alg,
+                                   SimpleIntegratorIMEXOptions}
+    u::uType
+    u1::uType
+    u2::uType
+    u3::uType
+    fu1::uType
+    fu2::uType
+    fu3::uType
+    du1::uType
+    du2::uType
+    du3::uType
+    du::uType
+    u_tmp1::uType
+    u_tmp2::uType
+    u_tmp3::uType
+    r0::uType
+    t::RealT
+    tdir::RealT
+    dt::RealT # current time step
+    dtcache::RealT # manually set time step
+    iter::Int # current number of time steps (iteration)
+    p::Params # will be the semidiscretization from Trixi
+    sol::Sol # faked
+    f::F
+    alg::Alg
+    opts::SimpleIntegratorIMEXOptions
+    finalstep::Bool # added for convenience
+    dtchangeable::Bool
+    force_stepfail::Bool
+end
+
+"""
+    add_tstop!(integrator::SimpleIntegratorSSP, t)
+Add a time stop during the time integration process.
+This function is called after the periodic SaveSolutionCallback to specify the next stop to save the solution.
+"""
+function add_tstop!(integrator::SimpleIntegratorIMEX, t)
+    integrator.tdir * (t - integrator.t) < zero(integrator.t) &&
+        error("Tried to add a tstop that is behind the current time. This is strictly forbidden")
+    # We need to remove the first entry of tstops when a new entry is added.
+    # Otherwise, the simulation gets stuck at the previous tstop and dt is adjusted to zero.
+    if length(integrator.opts.tstops) > 1
+        pop!(integrator.opts.tstops)
+    end
+    push!(integrator.opts.tstops, integrator.tdir * t)
+end
+
+has_tstop(integrator::SimpleIntegratorIMEX) = !isempty(integrator.opts.tstops)
+first_tstop(integrator::SimpleIntegratorIMEX) = first(integrator.opts.tstops)
+
+# Forward integrator.stats.naccept to integrator.iter (see GitHub PR#771)
+function Base.getproperty(integrator::SimpleIntegratorIMEX, field::Symbol)
+    if field === :stats
+        return (naccept = getfield(integrator, :iter),)
+    end
+    # general fallback
+    return getfield(integrator, field)
+end
+
+"""
+    solve(ode, alg; dt, callbacks, kwargs...)
+
+The following structures and methods provide the infrastructure for SSP Runge-Kutta methods
+of type `SimpleAlgorithmSSP`.
+
+!!! warning "Experimental implementation"
+    This is an experimental feature and may change in future releases.
+"""
+function solve(ode::ODEProblem, alg = SimpleAlgorithmIMEX()::SimpleAlgorithmIMEX;
+               dt, callback = nothing, kwargs...)
+    u = copy(ode.u0)
+    du1 = similar(u)
+    du2 = similar(u)
+    du3 = similar(u)
+    fu1 = similar(u)
+    fu2 = similar(u)
+    fu3 = similar(u)
+    du = similar(u)
+    u1 = similar(u)
+    u2 = similar(u)
+    u3 = similar(u)
+    u_tmp1 = similar(u)
+    u_tmp2 = similar(u)
+    u_tmp3 = similar(u)
+    r0 = similar(u)
+    t = first(ode.tspan)
+    tdir = sign(ode.tspan[end] - ode.tspan[1])
+    iter = 0
+    integrator = SimpleIntegratorIMEX(u,u1,u2,u3,fu1,fu2,fu3,du1,du2,du3,du,u_tmp1,u_tmp2,u_tmp3, r0, t, tdir, dt, dt, iter, ode.p,
+                                     (prob = ode,), ode.f, alg,
+                                     SimpleIntegratorIMEXOptions(callback, ode.tspan;
+                                                                kwargs...),
+                                     false, true, false)
+
+    # resize container
+    resize!(integrator.p, nelements(integrator.p.solver, integrator.p.cache))
+
+    # initialize callbacks
+    if callback isa CallbackSet
+        foreach(callback.continuous_callbacks) do cb
+            error("unsupported")
+        end
+        foreach(callback.discrete_callbacks) do cb
+            cb.initialize(cb, integrator.u, integrator.t, integrator)
+        end
+    elseif !isnothing(callback)
+        error("unsupported")
+    end
+
+    for stage_callback in alg.stage_callbacks
+        init_callback(stage_callback, integrator.p)
+    end
+
+    solve!(integrator)
+end
+
+function solve!(integrator::SimpleIntegratorIMEX)
+    @unpack prob = integrator.sol
+    @unpack alg = integrator
+    t_end = last(prob.tspan)
+    callbacks = integrator.opts.callback
+    semi = integrator.p
+    mesh, equations, solver, cache = Trixi.mesh_equations_solver_cache(semi)
+    relaxation_rate = equations.eps_relaxation
+    integrator.finalstep = false
+    @trixi_timeit timer() "main loop" while !integrator.finalstep
+            if isnan(integrator.dt)
+                error("time step size `dt` is NaN")
+            end
+
+            modify_dt_for_tstops!(integrator)
+            # if the next iteration would push the simulation beyond the end time, set dt accordingly
+                if integrator.t + integrator.dt > t_end ||
+                    isapprox(integrator.t + integrator.dt, t_end)
+                    integrator.dt = t_end - integrator.t
+                    terminate!(integrator)
+                end
+            integrator.u1 .= 0
+            integrator.u2 .= 0
+            integrator.u3 .= 0
+            integrator.du1 .= 0
+            integrator.du2 .= 0
+            integrator.du3 .= 0
+            integrator.fu1 .= 0
+            integrator.fu2 .= 0
+            integrator.fu3 .= 0
+            integrator.u_tmp1 .= 0
+            integrator.u_tmp2 .= 0
+            integrator.u_tmp3 .= 0
+                
+                #Ui = Un - dt sum A1_ij partial rhs(Uj) - dt/epsilon sum A2_ij (Vj - f(Uj))
+                #Un+1 = Un - dt sum bj partial rhs(Uj) - dt/epsilon sum bj (Vj - f(Uj))
+                
+                t_stage = integrator.t + integrator.dt * alg.c1[1]
+                
+                #   Stage 1
+                #Ui = (ui;vi)
+                #u1 = un
+                #v1 = vn - -dt/epsilon A2_{11} (v1 - f(u1)) 
+                
+              @.  integrator.u1 .= integrator.u  #u1 = v1 = un
+                
+              @. integrator.fu1 .= integrator.u1
+                 wrap_and_perform_projection!(integrator.fu1,integrator.dt,mesh,equations,solver,cache)  # compute f(u1)
+
+              @. integrator.u1 = integrator.u1 + integrator.dt/relaxation_rate*alg.A2[1,1]*integrator.fu1 # v1 = vn + dt/eps*A2_11 f(u1)
+                
+                divide_relaxed_var!(integrator.u1,integrator.dt,semi,solver,cache,alg.A2[1,1],equations)  # v1 = (vn + dt/eps*A2_11 f(u1))/(1 + dt/eps A2_11)
+               
+                integrator.f(integrator.du1, integrator.u1, integrator.p, t_stage) # compute RHS(u1,v1)
+
+                # Stage 2        
+                #u2 = un - dt A1_{21} rhs(u1,v1) 
+                #v2 = vn - dt A1_{21} rhs(u1,v1) - dt/epsilon A2_{21} (v1 - f(u1)) -dt/epsilon A2_{22} (v2 - f(u2)) 
+                
+                t_stage = integrator.t + integrator.dt * alg.c1[2]
+           
+                @. integrator.u2 = integrator.u - integrator.dt*alg.A1[2,1]*integrator.du1 # u2 = v2 = Un - dt*A1_22 RHS(U1)
+
+                @. integrator.fu2 = integrator.u2
+                wrap_and_perform_projection!(integrator.fu2,integrator.dt,mesh,equations,solver,cache) # compute f(u2) and setting the source term values to 0 for the cons variables
+                
+                @. integrator.u_tmp1 = integrator.u1
+                set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache) # computing v1 by setting cons variables to 0
+
+                # v2 = vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2)
+                @. integrator.u2 = integrator.u2 - integrator.dt/relaxation_rate*alg.A2[2,1]*(integrator.u_tmp1 - integrator.fu1) + integrator.dt*alg.A2[2,2]/relaxation_rate*integrator.fu2
+               
+                divide_relaxed_var!(integrator.u2,integrator.dt,semi,solver,cache,alg.A2[2,2],equations) # v2 = (vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2) ) ( 1+dt/eps A2_22)
+
+                integrator.f(integrator.du2, integrator.u2, integrator.p, t_stage)
+               
+                # Stage 3
+                #u3 = un - dt A1_{31} rhs(u1,v1) - dt A1_{32} rhs(u2,v2)
+                #v3 = vn - dt A1_{31} rhs(u1,v1) - dt A1_{32} rhs(u2,v2) - dt/epsilon A2_{31} (v1 - f(u1)) -dt/epsilon A2_{32} (v2 - f(u2)) -dt/epsilon A2_{33} (v3 - f(u3))
+                @. integrator.u3 = integrator.u - integrator.dt*alg.A1[3,1]*integrator.du1 - integrator.dt*alg.A1[3,2]*integrator.du2
+
+                @. integrator.fu3 = integrator.u3
+                wrap_and_perform_projection!(integrator.fu3,integrator.dt,mesh,equations,solver,cache)
+
+                #  @. integrator.u_tmp1 = integrator.u1
+                #  set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
+
+                @. integrator.u_tmp2 = integrator.u2
+                set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache)
+
+                @. integrator.u3 = integrator.u3 - integrator.dt/relaxation_rate*alg.A2[3,1]*(integrator.u_tmp1 - integrator.fu1) - integrator.dt/relaxation_rate*alg.A2[3,2]*(integrator.u_tmp2 - integrator.fu2) + integrator.dt*alg.A2[3,3]/relaxation_rate*integrator.fu3
+                
+                divide_relaxed_var!(integrator.u3,integrator.dt,semi,solver,cache,alg.A2[3,3],equations) 
+                
+                integrator.f(integrator.du3, integrator.u3, integrator.p, t_stage)
+                
+                # Final Stage
+                @. integrator.u = integrator.u - integrator.dt*alg.b[1]*integrator.du1 - integrator.dt*alg.b[2]*integrator.du2 - integrator.dt*alg.b[3]*integrator.du3
+                
+                # Already done that for u_tmp1 and u_tmp2, such that they are v1 = u_tmp1 and v2 = u_tmp2
+                # integrator.u_tmp1 .= integrator.u1              
+                # integrator.u_tmp2 .= integrator.u2
+                @. integrator.u_tmp3 = integrator.u3
+                # set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
+                # set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache)
+                set_cons_var_to_zero!(integrator.u_tmp3,semi,solver,cache)
+
+                @. integrator.u = integrator.u - integrator.dt/relaxation_rate*alg.b[1]*(integrator.u_tmp1 - integrator.fu1) - integrator.dt/relaxation_rate*alg.b[2]*(integrator.u_tmp2 - integrator.fu2) - integrator.dt*alg.b[3]/relaxation_rate*(integrator.u_tmp3 - integrator.fu3)
+             # End Stages   
+          #  for stage_callback in alg.stage_callbacks
+          #      stage_callback(integrator.u, integrator, 1)
+          #  end
+
+        integrator.iter += 1
+        integrator.t += integrator.dt
+
+        # handle callbacks
+        if callbacks isa CallbackSet
+            foreach(callbacks.discrete_callbacks) do cb
+                if cb.condition(integrator.u, integrator.t, integrator)
+                    cb.affect!(integrator)
+                end
+            end
+        end
+        
+        # respect maximum number of iterations
+        if integrator.iter >= integrator.opts.maxiters && !integrator.finalstep
+            @warn "Interrupted. Larger maxiters is needed."
+            terminate!(integrator)
+        end
+    end
+
+    # Empty the tstops array.
+    # This cannot be done in terminate!(integrator::SimpleIntegratorSSP) because DiffEqCallbacks.PeriodicCallbackAffect would return at error.
+    extract_all!(integrator.opts.tstops)
+
+    for stage_callback in alg.stage_callbacks
+        finalize_callback(stage_callback, integrator.p)
+    end
+
+    return TimeIntegratorSolution((first(prob.tspan), integrator.t),
+                                  (prob.u0, integrator.u), prob)
+end
+
+function divide_relaxed_var!(u,dt,semi,solver,cache,aii,equations)
+    u_wrap = Trixi.wrap_array(u,semi)
+    cycle_divide!(u_wrap,dt,semi,solver,cache,aii,equations)
+    return nothing
+end
+
+function cycle_divide!(u,dt,semi,solver,cache,aii,equations)
+
+         relaxation_rate = equations.eps_relaxation
+                for element in eachelement(solver,cache)
+                    for j in eachnode(solver),i in eachnode(solver)
+                        for var in 5:12
+                        u[var,i,j,element] = u[var,i,j,element]/(1.0+dt/relaxation_rate*aii)    
+                        end
+                    end
+                end
+
+    return nothing
+end
+
+function wrap_and_perform_projection!(u,dt,mesh,equations,solver,cache)
+
+                u_wrap = wrap_array(u, mesh, equations, solver, cache)
+                perform_projection_sourceterm!(u_wrap,dt,mesh,equations,solver,cache)
+    
+    return nothing
+end
+
+
+function set_cons_var_to_zero!(u,semi,solver,cache)
+                u_wrap = Trixi.wrap_array(u,semi)
+                for element in eachelement(solver, cache)    
+                    for j in eachnode(solver), i in eachnode(solver)
+                        for var in 1:4
+                u_wrap[var,i,j,element] = 0.0
+                        end        
+                    end
+                end
+    return nothing
+end
+
+function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D, equations::JinXinEquations, dg, cache)
+
+    # relaxation parameter
+    eps = equations.eps_relaxation
+    dt_ = dt
+    factor =1.0/ (eps + dt_)
+    eq_relax = equations.equations_base
+
+    # prepare local storage for projection
+    @unpack interpolate_N_to_M, project_M_to_N, filter_modal_to_N = dg.basis
+    nnodes_,nnodes_projection = size(project_M_to_N)
+    nVars = nvariables(eq_relax)
+    RealT = real(dg)
+    u_N = zeros(RealT, nVars, nnodes_, nnodes_)
+    w_N = zeros(RealT, nVars, nnodes_, nnodes_)
+    f_N = zeros(RealT, nVars, nnodes_, nnodes_)
+    g_N = zeros(RealT, nVars, nnodes_, nnodes_)
+    u_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    w_M_raw = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    w_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    f_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    g_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+
+    tmp_MxM = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    tmp_MxN = zeros(RealT, nVars, nnodes_projection, nnodes_)
+    tmp_NxM = zeros(RealT, nVars, nnodes_, nnodes_projection)
+
+#@threaded for element in eachelement(dg, cache)
+for element in eachelement(dg, cache)
+
+# get element u_N
+for j in eachnode(dg), i in eachnode(dg)
+    u_node = get_node_vars(u, equations, dg, i, j, element)
+    for v in eachvariable(eq_relax)
+        u_N[v,i,j] = u_node[v]
+    end
+end
+# bring elemtn u_N to grid (M+1)x(M+1)
+multiply_dimensionwise!(u_M,interpolate_N_to_M,u_N,tmp_MxN)
+
+# compute nodal values of entropy variables w on the M grid
+for j in 1:nnodes_projection, i in 1:nnodes_projection
+    u_cons = get_node_vars(u_M, eq_relax, dg, i, j)
+    w_ij   = cons2entropy(u_cons,eq_relax) 
+    set_node_vars!(w_M_raw,w_ij,eq_relax,dg,i,j)
+end
+# compute projection of w with M values down to N
+multiply_dimensionwise!(w_M,filter_modal_to_N,w_M_raw,tmp_MxM)
+
+#multiply_dimensionwise!(w_N,project_M_to_N,w_M)
+#multiply_dimensionwise!(w_M,interpolate_N_to_M,w_N)
+
+
+# compute nodal values of conservative f,g on the M grid
+for j in 1:nnodes_projection, i in 1:nnodes_projection
+    w_ij = get_node_vars(w_M, eq_relax, dg, i, j)
+    u_cons = entropy2cons(w_ij, eq_relax)
+    f_cons = flux(u_cons,1,eq_relax)
+    set_node_vars!(f_M,f_cons,eq_relax,dg,i,j)
+    g_cons = flux(u_cons,2,eq_relax)
+    set_node_vars!(g_M,g_cons,eq_relax,dg,i,j)
+end
+# compute projection of f with M values down to N, same for g
+multiply_dimensionwise!(f_N,project_M_to_N,f_M,tmp_NxM)
+multiply_dimensionwise!(g_N,project_M_to_N,g_M,tmp_NxM)
+#@assert nnodes_projection == nnodes(dg) 
+#for j in 1:nnodes_projection, i in 1:nnodes_projection
+#    u_cons = get_node_vars(u_N, eq_relax, dg, i, j)
+#    f_cons = flux(u_cons,1,eq_relax)
+#    set_node_vars!(f_N,f_cons,eq_relax,dg,i,j)
+#    g_cons = flux(u_cons,2,eq_relax)
+#    set_node_vars!(g_N,g_cons,eq_relax,dg,i,j)
+#end
+
+    for j in eachnode(dg), i in eachnode(dg)
+        u_node = get_node_vars(u, equations, dg, i, j, element)
+        # compute compressible Euler fluxes
+        vu = get_node_vars(f_N,eq_relax,dg,i,j)
+        wu = get_node_vars(g_N,eq_relax,dg,i,j)
+        # compute relaxation terms
+        du1 = 0.0
+        du2 = 0.0
+        du3 = 0.0
+        du4 = 0.0
+        du5 = vu[1]
+        du6 = vu[2]
+        du7 = vu[3]
+        du8 = vu[4]
+        du9 = wu[1]
+        du10= wu[2]
+        du11= wu[3]
+        du12= wu[4]
+        new_u = SVector(du1, du2, du3, du4, du5, du6, du7, du8, du9, du10, du11, du12)
+        set_node_vars!(u, new_u, equations, dg, i, j, element)
+    end
+end
+return nothing
+end
+
+# get a cache where the RHS can be stored
+get_du(integrator::SimpleIntegratorIMEX) = integrator.du
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.r0,)
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.fu1,)
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.fu2,)
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.fu3,)
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.du1,)
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.du2,)
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.du3,)
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.u1,)
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.u2,)
+get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.u3,)
+
+# some algorithms from DiffEq like FSAL-ones need to be informed when a callback has modified u
+u_modified!(integrator::SimpleIntegratorIMEX, ::Bool) = false
+
+# used by adaptive timestepping algorithms in DiffEq
+function set_proposed_dt!(integrator::SimpleIntegratorIMEX, dt)
+    (integrator.dt = dt; integrator.dtcache = dt)
+end
+
+# used by adaptive timestepping algorithms in DiffEq
+function get_proposed_dt(integrator::SimpleIntegratorIMEX)
+    return ifelse(integrator.opts.adaptive, integrator.dt, integrator.dtcache)
+end
+
+# stop the time integration
+function terminate!(integrator::SimpleIntegratorIMEX)
+    integrator.finalstep = true
+end
+
+"""
+    modify_dt_for_tstops!(integrator::SimpleIntegratorSSP)
+Modify the time-step size to match the time stops specified in integrator.opts.tstops.
+To avoid adding OrdinaryDiffEq to Trixi's dependencies, this routine is a copy of
+https://github.com/SciML/OrdinaryDiffEq.jl/blob/d76335281c540ee5a6d1bd8bb634713e004f62ee/src/integrators/integrator_utils.jl#L38-L54
+"""
+function modify_dt_for_tstops!(integrator::SimpleIntegratorIMEX)
+    if has_tstop(integrator)
+        tdir_t = integrator.tdir * integrator.t
+        tdir_tstop = first_tstop(integrator)
+        if integrator.opts.adaptive
+            integrator.dt = integrator.tdir *
+                            min(abs(integrator.dt), abs(tdir_tstop - tdir_t)) # step! to the end
+        elseif iszero(integrator.dtcache) && integrator.dtchangeable
+            integrator.dt = integrator.tdir * abs(tdir_tstop - tdir_t)
+        elseif integrator.dtchangeable && !integrator.force_stepfail
+            # always try to step! with dtcache, but lower if a tstop
+            # however, if force_stepfail then don't set to dtcache, and no tstop worry
+            integrator.dt = integrator.tdir *
+                            min(abs(integrator.dtcache), abs(tdir_tstop - tdir_t)) # step! to the end
+        end
+    end
+end
+
+# used for AMR
+function Base.resize!(integrator::SimpleIntegratorIMEX, new_size)
+    resize!(integrator.u, new_size)
+    resize!(integrator.du, new_size)
+    resize!(integrator.r0, new_size)
+
+    # Resize container
+    # new_size = n_variables * n_nodes^n_dims * n_elements
+    n_elements = nelements(integrator.p.solver, integrator.p.cache)
+    resize!(integrator.p, n_elements)
+end
+
+function Base.resize!(semi::AbstractSemidiscretization, new_size)
+    resize!(semi, semi.solver.volume_integral, new_size)
+end
+
+Base.resize!(semi, volume_integral::AbstractVolumeIntegral, new_size) = nothing
+
+function Base.resize!(semi, volume_integral::VolumeIntegralSubcellLimiting, new_size)
+    # Resize container antidiffusive_fluxes
+    resize!(semi.cache.antidiffusive_fluxes, new_size)
+
+    # Resize container subcell_limiter_coefficients
+    @unpack limiter = volume_integral
+    resize!(limiter.cache.subcell_limiter_coefficients, new_size)
+end
+end # @muladd
diff --git a/src/time_integration/time_integration.jl b/src/time_integration/time_integration.jl
index d19a1fcc37..e8ecb7b5ce 100644
--- a/src/time_integration/time_integration.jl
+++ b/src/time_integration/time_integration.jl
@@ -17,4 +17,5 @@ include("methods_2N.jl")
 include("methods_3Sstar.jl")
 include("methods_SSP.jl")
 include("paired_explicit_runge_kutta/paired_explicit_runge_kutta.jl")
+include("methods_IMEXJinXin")
 end # @muladd

From c53d286e358eac8fb3f0ec6a2f705a1250777d90 Mon Sep 17 00:00:00 2001
From: Marco <artianomarco97@gmail.com>
Date: Fri, 31 May 2024 12:36:07 +0200
Subject: [PATCH 02/13] Jacobian added

---
 .../tree_2d_dgsem/elixir_jin_xin_euler.jl     |  9 +++++----
 src/time_integration/methods_IMEXJinXin.jl    | 19 +++++++++++++------
 src/time_integration/time_integration.jl      |  2 +-
 3 files changed, 19 insertions(+), 11 deletions(-)

diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
index 3792231914..fb0f9c508b 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
@@ -5,7 +5,7 @@ using Trixi
 ###############################################################################
 # semidiscretization of the compressible Euler equations
 
-epsilon_relaxation = 1.0e-6
+epsilon_relaxation = 1.0e-8
 a1 = a2 = a3 = a4 = 30.0
 b1 = b2 = b3 = b4 = 30.0
 
@@ -61,7 +61,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)#
 ###############################################################################
 # ODE solvers, callbacks etc.
 
-tspan = (0.0, 3.7)
+tspan = (0.0, 0.0)
 #tspan = (0.0, 1.0)
 ode = semidiscretize(semi, tspan)
 
@@ -77,7 +77,7 @@ save_solution = SaveSolutionCallback(interval=1000,
                                      save_final_solution=true,
                                      solution_variables=cons2prim)
 
-stepsize_callback = StepsizeCallback(cfl=0.5)
+stepsize_callback = StepsizeCallback(cfl=0.01)
 
 callbacks = CallbackSet(summary_callback,
                         analysis_callback, alive_callback,
@@ -89,7 +89,8 @@ stage_limiter! = PositivityPreservingLimiterZhangShu(thresholds=(5.0e-6, 5.0e-6)
                                                      variables=(Trixi.density, pressure))
 
 #sol = solve(ode, CarpenterKennedy2N54(stage_limiter!,williamson_condition=false),
-sol = solve(ode, SSPRK43(stage_limiter!),
+#sol = solve(ode, SSPRK43(stage_limiter!),
+sol = Trixi.solve(ode, Trixi.SimpleIMEX(),
 #sol = solve(ode, SSPRK33(stage_limiter!),
 #sol = solve(ode, RDPK3SpFSAL49(),
 #sol = solve(ode, AutoTsit5(Rosenbrock23()),
diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index 30c1b8252e..71dc557626 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -358,12 +358,13 @@ function divide_relaxed_var!(u,dt,semi,solver,cache,aii,equations)
 end
 
 function cycle_divide!(u,dt,semi,solver,cache,aii,equations)
-
+    @unpack inverse_jacobian = cache.elements
          relaxation_rate = equations.eps_relaxation
                 for element in eachelement(solver,cache)
+                    factor = inverse_jacobian[element]
                     for j in eachnode(solver),i in eachnode(solver)
                         for var in 5:12
-                        u[var,i,j,element] = u[var,i,j,element]/(1.0+dt/relaxation_rate*aii)    
+                        u[var,i,j,element] = u[var,i,j,element]/(1.0+factor*dt/relaxation_rate*aii)    
                         end
                     end
                 end
@@ -382,11 +383,16 @@ end
 
 function set_cons_var_to_zero!(u,semi,solver,cache)
                 u_wrap = Trixi.wrap_array(u,semi)
+    @unpack inverse_jacobian = cache.elements
                 for element in eachelement(solver, cache)    
+                    factor = inverse_jacobian[element]
                     for j in eachnode(solver), i in eachnode(solver)
                         for var in 1:4
-                u_wrap[var,i,j,element] = 0.0
-                        end        
+                           u_wrap[var,i,j,element] = 0.0
+                        end
+                        for var in 5:12
+                           u_wrap[var,i,j,element] *= factor 
+                        end
                     end
                 end
     return nothing
@@ -397,9 +403,9 @@ function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D, equations::JinX
     # relaxation parameter
     eps = equations.eps_relaxation
     dt_ = dt
-    factor =1.0/ (eps + dt_)
     eq_relax = equations.equations_base
 
+    @unpack inverse_jacobian = cache.elements
     # prepare local storage for projection
     @unpack interpolate_N_to_M, project_M_to_N, filter_modal_to_N = dg.basis
     nnodes_,nnodes_projection = size(project_M_to_N)
@@ -422,6 +428,7 @@ function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D, equations::JinX
 #@threaded for element in eachelement(dg, cache)
 for element in eachelement(dg, cache)
 
+                    factor = inverse_jacobian[element]
 # get element u_N
 for j in eachnode(dg), i in eachnode(dg)
     u_node = get_node_vars(u, equations, dg, i, j, element)
@@ -484,7 +491,7 @@ multiply_dimensionwise!(g_N,project_M_to_N,g_M,tmp_NxM)
         du10= wu[2]
         du11= wu[3]
         du12= wu[4]
-        new_u = SVector(du1, du2, du3, du4, du5, du6, du7, du8, du9, du10, du11, du12)
+        new_u = factor*SVector(du1, du2, du3, du4, du5, du6, du7, du8, du9, du10, du11, du12)
         set_node_vars!(u, new_u, equations, dg, i, j, element)
     end
 end
diff --git a/src/time_integration/time_integration.jl b/src/time_integration/time_integration.jl
index e8ecb7b5ce..a47f1f89a7 100644
--- a/src/time_integration/time_integration.jl
+++ b/src/time_integration/time_integration.jl
@@ -17,5 +17,5 @@ include("methods_2N.jl")
 include("methods_3Sstar.jl")
 include("methods_SSP.jl")
 include("paired_explicit_runge_kutta/paired_explicit_runge_kutta.jl")
-include("methods_IMEXJinXin")
+include("methods_IMEXJinXin.jl")
 end # @muladd

From ec7688ce5ca7266a316354978b572a8ee0372020 Mon Sep 17 00:00:00 2001
From: Marco <artianomarco97@gmail.com>
Date: Fri, 31 May 2024 13:33:04 +0200
Subject: [PATCH 03/13] Generalized IMEX Tree Mesh 2D

---
 .../tree_2d_dgsem/elixir_jin_xin_euler.jl     |  7 ++-
 src/time_integration/methods_IMEXJinXin.jl    | 43 ++++++++-----------
 2 files changed, 22 insertions(+), 28 deletions(-)

diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
index fb0f9c508b..f3d994ecea 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
@@ -1,11 +1,10 @@
-
 using OrdinaryDiffEq
 using Trixi
 
 ###############################################################################
 # semidiscretization of the compressible Euler equations
 
-epsilon_relaxation = 1.0e-8
+epsilon_relaxation = 1.0e-6
 a1 = a2 = a3 = a4 = 30.0
 b1 = b2 = b3 = b4 = 30.0
 
@@ -61,7 +60,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)#
 ###############################################################################
 # ODE solvers, callbacks etc.
 
-tspan = (0.0, 0.0)
+tspan = (0.0, 3.6)
 #tspan = (0.0, 1.0)
 ode = semidiscretize(semi, tspan)
 
@@ -77,7 +76,7 @@ save_solution = SaveSolutionCallback(interval=1000,
                                      save_final_solution=true,
                                      solution_variables=cons2prim)
 
-stepsize_callback = StepsizeCallback(cfl=0.01)
+stepsize_callback = StepsizeCallback(cfl=0.5)
 
 callbacks = CallbackSet(summary_callback,
                         analysis_callback, alive_callback,
diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index 71dc557626..b7448420ae 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -250,8 +250,7 @@ function solve!(integrator::SimpleIntegratorIMEX)
                 #Ui = (ui;vi)
                 #u1 = un
                 #v1 = vn - -dt/epsilon A2_{11} (v1 - f(u1)) 
-                
-              @.  integrator.u1 .= integrator.u  #u1 = v1 = un
+              @. integrator.u1 .= integrator.u  #u1 = v1 = un
                 
               @. integrator.fu1 .= integrator.u1
                  wrap_and_perform_projection!(integrator.fu1,integrator.dt,mesh,equations,solver,cache)  # compute f(u1)
@@ -274,7 +273,7 @@ function solve!(integrator::SimpleIntegratorIMEX)
                 wrap_and_perform_projection!(integrator.fu2,integrator.dt,mesh,equations,solver,cache) # compute f(u2) and setting the source term values to 0 for the cons variables
                 
                 @. integrator.u_tmp1 = integrator.u1
-                set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache) # computing v1 by setting cons variables to 0
+                set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache,equations) # computing v1 by setting cons variables to 0
 
                 # v2 = vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2)
                 @. integrator.u2 = integrator.u2 - integrator.dt/relaxation_rate*alg.A2[2,1]*(integrator.u_tmp1 - integrator.fu1) + integrator.dt*alg.A2[2,2]/relaxation_rate*integrator.fu2
@@ -295,7 +294,7 @@ function solve!(integrator::SimpleIntegratorIMEX)
                 #  set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
 
                 @. integrator.u_tmp2 = integrator.u2
-                set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache)
+                set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache,equations)
 
                 @. integrator.u3 = integrator.u3 - integrator.dt/relaxation_rate*alg.A2[3,1]*(integrator.u_tmp1 - integrator.fu1) - integrator.dt/relaxation_rate*alg.A2[3,2]*(integrator.u_tmp2 - integrator.fu2) + integrator.dt*alg.A2[3,3]/relaxation_rate*integrator.fu3
                 
@@ -312,10 +311,10 @@ function solve!(integrator::SimpleIntegratorIMEX)
                 @. integrator.u_tmp3 = integrator.u3
                 # set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
                 # set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache)
-                set_cons_var_to_zero!(integrator.u_tmp3,semi,solver,cache)
+                set_cons_var_to_zero!(integrator.u_tmp3,semi,solver,cache,equations)
 
                 @. integrator.u = integrator.u - integrator.dt/relaxation_rate*alg.b[1]*(integrator.u_tmp1 - integrator.fu1) - integrator.dt/relaxation_rate*alg.b[2]*(integrator.u_tmp2 - integrator.fu2) - integrator.dt*alg.b[3]/relaxation_rate*(integrator.u_tmp3 - integrator.fu3)
-             # End Stages   
+                # End Stages   
           #  for stage_callback in alg.stage_callbacks
           #      stage_callback(integrator.u, integrator, 1)
           #  end
@@ -359,11 +358,12 @@ end
 
 function cycle_divide!(u,dt,semi,solver,cache,aii,equations)
     @unpack inverse_jacobian = cache.elements
+                nvars_base = nvariables(equations.equations_base)
          relaxation_rate = equations.eps_relaxation
                 for element in eachelement(solver,cache)
                     factor = inverse_jacobian[element]
                     for j in eachnode(solver),i in eachnode(solver)
-                        for var in 5:12
+                        for var in (nvars_base+1):(nvars_base*3)
                         u[var,i,j,element] = u[var,i,j,element]/(1.0+factor*dt/relaxation_rate*aii)    
                         end
                     end
@@ -381,16 +381,17 @@ function wrap_and_perform_projection!(u,dt,mesh,equations,solver,cache)
 end
 
 
-function set_cons_var_to_zero!(u,semi,solver,cache)
+function set_cons_var_to_zero!(u,semi,solver,cache,equations)
                 u_wrap = Trixi.wrap_array(u,semi)
+                nvars_base = nvariables(equations.equations_base)
     @unpack inverse_jacobian = cache.elements
                 for element in eachelement(solver, cache)    
                     factor = inverse_jacobian[element]
                     for j in eachnode(solver), i in eachnode(solver)
-                        for var in 1:4
+                        for var in 1:nvars_base
                            u_wrap[var,i,j,element] = 0.0
                         end
-                        for var in 5:12
+                        for var in (nvars_base+1):(nvars_base*3)
                            u_wrap[var,i,j,element] *= factor 
                         end
                     end
@@ -478,26 +479,20 @@ multiply_dimensionwise!(g_N,project_M_to_N,g_M,tmp_NxM)
         # compute compressible Euler fluxes
         vu = get_node_vars(f_N,eq_relax,dg,i,j)
         wu = get_node_vars(g_N,eq_relax,dg,i,j)
-        # compute relaxation terms
-        du1 = 0.0
-        du2 = 0.0
-        du3 = 0.0
-        du4 = 0.0
-        du5 = vu[1]
-        du6 = vu[2]
-        du7 = vu[3]
-        du8 = vu[4]
-        du9 = wu[1]
-        du10= wu[2]
-        du11= wu[3]
-        du12= wu[4]
-        new_u = factor*SVector(du1, du2, du3, du4, du5, du6, du7, du8, du9, du10, du11, du12)
+        u_base = get_block_components2(u_node, 1, equations)
+        new_u = factor*SVector(zero(u_node)..., vu..., wu...)
         set_node_vars!(u, new_u, equations, dg, i, j, element)
     end
 end
 return nothing
 end
 
+function get_block_components2(u, n, equations::JinXinEquations)
+    nvars_base = nvariables(equations.equations_base)
+    return SVector(ntuple(i -> u[i + (n - 1) * nvars_base], Val(nvars_base)))
+end
+
+
 # get a cache where the RHS can be stored
 get_du(integrator::SimpleIntegratorIMEX) = integrator.du
 get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.r0,)

From bbd994bc346e810826271b4e4b0a12d39237b31a Mon Sep 17 00:00:00 2001
From: Marco <artianomarco97@gmail.com>
Date: Fri, 31 May 2024 14:32:00 +0200
Subject: [PATCH 04/13] fixed sign in the time integrator; working on 1D
 implementation

---
 .../elixir_burgers_linear_stability.jl        |   3 +-
 .../tree_1d_dgsem/elixir_jin_xin_burgers.jl   |  57 +++++++
 .../tree_2d_dgsem/elixir_jin_xin_euler.jl     |   7 +-
 .../jin_xin_compressible_euler_2d.jl          |  36 ++++-
 src/time_integration/methods_IMEXJinXin.jl    | 147 ++++++++++++++++--
 5 files changed, 231 insertions(+), 19 deletions(-)
 create mode 100644 examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl

diff --git a/examples/tree_1d_dgsem/elixir_burgers_linear_stability.jl b/examples/tree_1d_dgsem/elixir_burgers_linear_stability.jl
index ae2039edde..e8ee9311a2 100644
--- a/examples/tree_1d_dgsem/elixir_burgers_linear_stability.jl
+++ b/examples/tree_1d_dgsem/elixir_burgers_linear_stability.jl
@@ -1,4 +1,3 @@
-
 using OrdinaryDiffEq
 using Trixi
 
@@ -52,4 +51,4 @@ callbacks = CallbackSet(summary_callback,
 sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
             dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
             save_everystep = false, callback = callbacks);
-summary_callback() # print the timer summary
+summary_callback() # print the timer summary
\ No newline at end of file
diff --git a/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl b/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
new file mode 100644
index 0000000000..134980a633
--- /dev/null
+++ b/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
@@ -0,0 +1,57 @@
+
+using OrdinaryDiffEq
+using Trixi
+
+###############################################################################
+# semidiscretization of the (inviscid) Burgers' equation
+epsilon_relaxation = 1.0e-6
+a1 = 10.0
+
+equations_base = InviscidBurgersEquation1D()
+velocities = (SVector(a1),)
+equations = JinXinEquations(equations_base,epsilon_relaxation, velocities)
+function initial_condition_linear_stability(x, t, equation::InviscidBurgersEquation1D)
+    k = 1
+    u = 2 + sinpi(k * (x[1] - 0.7))
+    return prim2cons(SVector(u),equations)
+end
+
+basis = LobattoLegendreBasis(3)
+solver = DGSEM(basis,Trixi.flux_upwind)
+
+
+coordinates_min = -1.0
+coordinates_max = 1.0
+mesh = TreeMesh(coordinates_min, coordinates_max,
+                initial_refinement_level = 4,
+                n_cells_max = 10_000)
+initial_condition = Trixi.InitialConditionJinXin(initial_condition_linear_stability)
+
+semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)
+
+###############################################################################
+# ODE solvers, callbacks etc.
+
+tspan = (0.0, 2.0)
+ode = semidiscretize(semi, tspan)
+
+summary_callback = SummaryCallback()
+
+analysis_interval = 100
+analysis_callback = AnalysisCallback(semi, interval = analysis_interval)
+
+alive_callback = AliveCallback(analysis_interval = analysis_interval)
+
+stepsize_callback = StepsizeCallback(cfl = 0.5)
+
+callbacks = CallbackSet(summary_callback,
+                        analysis_callback, alive_callback,
+                        stepsize_callback)
+
+###############################################################################
+# run the simulation
+
+sol = Trixi.solve(ode, Trixi.SimpleIMEX(),
+            dt = 1.0e-3, # solve needs some value here but it will be overwritten by the stepsize_callback
+            save_everystep = false, callback = callbacks,maxiters=1e7);
+summary_callback() # print the timer summary
diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
index f3d994ecea..969e718d2d 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
@@ -31,10 +31,11 @@ initial_condition = Trixi.InitialConditionJinXin(initial_condition_kelvin_helmho
 #initial_condition = Trixi.InitialConditionJinXin(initial_condition_density_wave)
 polydeg = 3
 polydeg_cutoff = 3
-basis = GaussLegendreBasis(polydeg; polydeg_projection = polydeg, polydeg_cutoff = polydeg_cutoff)
-# solver = DGSEM(basis, Trixi.flux_upwind)
+#basis = GaussLegendreBasis(polydeg; polydeg_projection = polydeg, polydeg_cutoff = polydeg_cutoff)
+basis = LobattoLegendreBasis(polydeg; polydeg_projection = 3)
+solver = DGSEM(basis, Trixi.flux_upwind)
 #solver = DGSEM(basis, Trixi.flux_upwind, VolumeIntegralWeakFormProjection())
-solver = DGSEM(basis, Trixi.flux_upwind, VolumeIntegralWeakForm())
+#solver = DGSEM(basis, Trixi.flux_upwind, VolumeIntegralWeakForm())
 #solver = DGSEM(polydeg = 3, surface_flux = Trixi.flux_upwind)
 
 #surface_flux = Trixi.flux_upwind
diff --git a/src/equations/jin_xin_compressible_euler_2d.jl b/src/equations/jin_xin_compressible_euler_2d.jl
index 7636ccc731..7c1e8aaa79 100644
--- a/src/equations/jin_xin_compressible_euler_2d.jl
+++ b/src/equations/jin_xin_compressible_euler_2d.jl
@@ -13,7 +13,6 @@ TODO: Write a proper docstring
 struct JinXinEquations{NDIMS, NVARS, NVARS_BASE, EquationsBase <: AbstractEquations{NDIMS, NVARS_BASE}, RealT <: Real} <:
        AbstractJinXinEquations{NDIMS, NVARS}
     equations_base::EquationsBase
-
     # relaxation parameter of the Jin Xin relaxation model
     # The relaxed equations should converge to the original equations
     # as the relaxation parameter epsilon -> 0
@@ -155,6 +154,15 @@ end
     end
 end
 
+
+@inline function flux(u, orientation::Integer, equations::JinXinEquations{1})
+        u_base = get_block_components(u, 1, equations)
+        fluxes = get_block_components(u, 2, equations)
+        velocities = equations.velocities[1]
+        return SVector(fluxes..., (velocities .* u_base)...)
+end
+
+
 # TODO: Implement 1D and 3D
 @inline function flux_upwind(u_ll, u_rr, orientation::Integer,
                              equations::JinXinEquations{2})
@@ -184,6 +192,22 @@ end
 end
 
 
+@inline function flux_upwind(u_ll, u_rr, orientation::Integer,
+                             equations::JinXinEquations{1})
+    u_ll_base = get_block_components(u_ll, 1, equations)
+    u_rr_base = get_block_components(u_rr, 1, equations)
+
+        sqrt_velocities = equations.sqrt_velocities[1]
+        f_ll_base = get_block_components(u_ll, 2, equations)
+        f_rr_base = get_block_components(u_rr, 2, equations)
+        dissipation = SVector((sqrt_velocities .* (u_rr_base - u_ll_base))...,
+                              #   (sqrt_velocities .* (f_rr_base + f_ll_base))..., @ranocha: is this correct?
+                              (sqrt_velocities .* (f_rr_base - f_ll_base))...)
+    return 0.5f0 * (flux(u_ll, orientation, equations) +
+                    flux(u_rr, orientation, equations) - dissipation)
+end
+
+
 @inline function max_abs_speeds(u, equations::JinXinEquations{2})
     return ntuple(Val(ndims(equations))) do n
         # maximum(equations.sqrt_velocities_inv[n]) @ranocha: is this correct?
@@ -191,10 +215,20 @@ end
     end
 end
 
+
+@inline function max_abs_speeds(u, equations::JinXinEquations{1})
+    return ntuple(Val(ndims(equations))) do n
+        # maximum(equations.sqrt_velocities_inv[n]) @ranocha: is this correct?
+        maximum(equations.sqrt_velocities[n])
+    end
+end
+
 # TODO: not correct yet!!
 # Convert conservative variables to primitive
 @inline cons2prim(u, equations::JinXinEquations) = u
 
 # Convert conservative variables to entropy variables
 @inline cons2entropy(u, equations::JinXinEquations) = u
+
+@inline prim2cons(u, equations::JinXinEquations) = u
 end # @muladd
diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index b7448420ae..2e8942e1cb 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -257,7 +257,7 @@ function solve!(integrator::SimpleIntegratorIMEX)
 
               @. integrator.u1 = integrator.u1 + integrator.dt/relaxation_rate*alg.A2[1,1]*integrator.fu1 # v1 = vn + dt/eps*A2_11 f(u1)
                 
-                divide_relaxed_var!(integrator.u1,integrator.dt,semi,solver,cache,alg.A2[1,1],equations)  # v1 = (vn + dt/eps*A2_11 f(u1))/(1 + dt/eps A2_11)
+                divide_relaxed_var!(integrator.u1,integrator.dt,semi,solver,cache,alg.A2[1,1],equations,mesh)  # v1 = (vn + dt/eps*A2_11 f(u1))/(1 + dt/eps A2_11)
                
                 integrator.f(integrator.du1, integrator.u1, integrator.p, t_stage) # compute RHS(u1,v1)
 
@@ -267,25 +267,25 @@ function solve!(integrator::SimpleIntegratorIMEX)
                 
                 t_stage = integrator.t + integrator.dt * alg.c1[2]
            
-                @. integrator.u2 = integrator.u - integrator.dt*alg.A1[2,1]*integrator.du1 # u2 = v2 = Un - dt*A1_22 RHS(U1)
+                @. integrator.u2 = integrator.u + integrator.dt*alg.A1[2,1]*integrator.du1 # u2 = v2 = Un - dt*A1_22 RHS(U1)
 
                 @. integrator.fu2 = integrator.u2
                 wrap_and_perform_projection!(integrator.fu2,integrator.dt,mesh,equations,solver,cache) # compute f(u2) and setting the source term values to 0 for the cons variables
                 
                 @. integrator.u_tmp1 = integrator.u1
-                set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache,equations) # computing v1 by setting cons variables to 0
+                set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache,equations,mesh) # computing v1 by setting cons variables to 0
 
                 # v2 = vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2)
                 @. integrator.u2 = integrator.u2 - integrator.dt/relaxation_rate*alg.A2[2,1]*(integrator.u_tmp1 - integrator.fu1) + integrator.dt*alg.A2[2,2]/relaxation_rate*integrator.fu2
                
-                divide_relaxed_var!(integrator.u2,integrator.dt,semi,solver,cache,alg.A2[2,2],equations) # v2 = (vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2) ) ( 1+dt/eps A2_22)
+                divide_relaxed_var!(integrator.u2,integrator.dt,semi,solver,cache,alg.A2[2,2],equations,mesh) # v2 = (vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2) ) ( 1+dt/eps A2_22)
 
                 integrator.f(integrator.du2, integrator.u2, integrator.p, t_stage)
                
                 # Stage 3
                 #u3 = un - dt A1_{31} rhs(u1,v1) - dt A1_{32} rhs(u2,v2)
                 #v3 = vn - dt A1_{31} rhs(u1,v1) - dt A1_{32} rhs(u2,v2) - dt/epsilon A2_{31} (v1 - f(u1)) -dt/epsilon A2_{32} (v2 - f(u2)) -dt/epsilon A2_{33} (v3 - f(u3))
-                @. integrator.u3 = integrator.u - integrator.dt*alg.A1[3,1]*integrator.du1 - integrator.dt*alg.A1[3,2]*integrator.du2
+                @. integrator.u3 = integrator.u + integrator.dt*alg.A1[3,1]*integrator.du1 + integrator.dt*alg.A1[3,2]*integrator.du2
 
                 @. integrator.fu3 = integrator.u3
                 wrap_and_perform_projection!(integrator.fu3,integrator.dt,mesh,equations,solver,cache)
@@ -294,16 +294,16 @@ function solve!(integrator::SimpleIntegratorIMEX)
                 #  set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
 
                 @. integrator.u_tmp2 = integrator.u2
-                set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache,equations)
+                set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache,equations,mesh)
 
                 @. integrator.u3 = integrator.u3 - integrator.dt/relaxation_rate*alg.A2[3,1]*(integrator.u_tmp1 - integrator.fu1) - integrator.dt/relaxation_rate*alg.A2[3,2]*(integrator.u_tmp2 - integrator.fu2) + integrator.dt*alg.A2[3,3]/relaxation_rate*integrator.fu3
                 
-                divide_relaxed_var!(integrator.u3,integrator.dt,semi,solver,cache,alg.A2[3,3],equations) 
+                divide_relaxed_var!(integrator.u3,integrator.dt,semi,solver,cache,alg.A2[3,3],equations,mesh) 
                 
                 integrator.f(integrator.du3, integrator.u3, integrator.p, t_stage)
                 
                 # Final Stage
-                @. integrator.u = integrator.u - integrator.dt*alg.b[1]*integrator.du1 - integrator.dt*alg.b[2]*integrator.du2 - integrator.dt*alg.b[3]*integrator.du3
+                @. integrator.u = integrator.u + integrator.dt*alg.b[1]*integrator.du1 + integrator.dt*alg.b[2]*integrator.du2 + integrator.dt*alg.b[3]*integrator.du3
                 
                 # Already done that for u_tmp1 and u_tmp2, such that they are v1 = u_tmp1 and v2 = u_tmp2
                 # integrator.u_tmp1 .= integrator.u1              
@@ -311,7 +311,7 @@ function solve!(integrator::SimpleIntegratorIMEX)
                 @. integrator.u_tmp3 = integrator.u3
                 # set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
                 # set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache)
-                set_cons_var_to_zero!(integrator.u_tmp3,semi,solver,cache,equations)
+                set_cons_var_to_zero!(integrator.u_tmp3,semi,solver,cache,equations,mesh)
 
                 @. integrator.u = integrator.u - integrator.dt/relaxation_rate*alg.b[1]*(integrator.u_tmp1 - integrator.fu1) - integrator.dt/relaxation_rate*alg.b[2]*(integrator.u_tmp2 - integrator.fu2) - integrator.dt*alg.b[3]/relaxation_rate*(integrator.u_tmp3 - integrator.fu3)
                 # End Stages   
@@ -350,13 +350,13 @@ function solve!(integrator::SimpleIntegratorIMEX)
                                   (prob.u0, integrator.u), prob)
 end
 
-function divide_relaxed_var!(u,dt,semi,solver,cache,aii,equations)
+function divide_relaxed_var!(u,dt,semi,solver,cache,aii,equations,mesh)
     u_wrap = Trixi.wrap_array(u,semi)
-    cycle_divide!(u_wrap,dt,semi,solver,cache,aii,equations)
+    cycle_divide!(u_wrap,dt,semi,solver,cache,aii,equations,mesh)
     return nothing
 end
 
-function cycle_divide!(u,dt,semi,solver,cache,aii,equations)
+function cycle_divide!(u,dt,semi,solver,cache,aii,equations,mesh::TreeMesh2D)
     @unpack inverse_jacobian = cache.elements
                 nvars_base = nvariables(equations.equations_base)
          relaxation_rate = equations.eps_relaxation
@@ -372,6 +372,23 @@ function cycle_divide!(u,dt,semi,solver,cache,aii,equations)
     return nothing
 end
 
+
+function cycle_divide!(u,dt,semi,solver,cache,aii,equations,mesh::TreeMesh1D)
+    @unpack inverse_jacobian = cache.elements
+                nvars_base = nvariables(equations.equations_base)
+         relaxation_rate = equations.eps_relaxation
+                for element in eachelement(solver,cache)
+                    factor = inverse_jacobian[element]
+                    for i in eachnode(solver)
+                        for var in (nvars_base+1):(nvars_base*2)
+                        u[var,i,element] = u[var,i,element]/(1.0+factor*dt/relaxation_rate*aii)    
+                        end
+                    end
+                end
+
+    return nothing
+end
+
 function wrap_and_perform_projection!(u,dt,mesh,equations,solver,cache)
 
                 u_wrap = wrap_array(u, mesh, equations, solver, cache)
@@ -381,7 +398,7 @@ function wrap_and_perform_projection!(u,dt,mesh,equations,solver,cache)
 end
 
 
-function set_cons_var_to_zero!(u,semi,solver,cache,equations)
+function set_cons_var_to_zero!(u,semi,solver,cache,equations, mesh::TreeMesh2D)
                 u_wrap = Trixi.wrap_array(u,semi)
                 nvars_base = nvariables(equations.equations_base)
     @unpack inverse_jacobian = cache.elements
@@ -399,6 +416,110 @@ function set_cons_var_to_zero!(u,semi,solver,cache,equations)
     return nothing
 end
 
+
+function set_cons_var_to_zero!(u,semi,solver,cache,equations, mesh::TreeMesh1D)
+                u_wrap = Trixi.wrap_array(u,semi)
+                nvars_base = nvariables(equations.equations_base)
+    @unpack inverse_jacobian = cache.elements
+                for element in eachelement(solver, cache)    
+                    factor = inverse_jacobian[element]
+                    for i in eachnode(solver)
+                        for var in 1:nvars_base
+                           u_wrap[var,i,element] = 0.0
+                        end
+                        for var in (nvars_base+1):(nvars_base*2)
+                           u_wrap[var,i,element] *= factor 
+                        end
+                    end
+                end
+    return nothing
+end
+
+function perform_projection_sourceterm!(u, dt, mesh::TreeMesh1D, equations::JinXinEquations, dg, cache)
+
+    # relaxation parameter
+    eps = equations.eps_relaxation
+    dt_ = dt
+    eq_relax = equations.equations_base
+
+    @unpack inverse_jacobian = cache.elements
+    # prepare local storage for projection
+    @unpack interpolate_N_to_M, project_M_to_N, filter_modal_to_N = dg.basis
+    nnodes_,nnodes_projection = size(project_M_to_N)
+    nVars = nvariables(eq_relax)
+    RealT = real(dg)
+    u_N = zeros(RealT, nVars, nnodes_)
+    w_N = zeros(RealT, nVars, nnodes_)
+    f_N = zeros(RealT, nVars, nnodes_)
+    g_N = zeros(RealT, nVars, nnodes_)
+    u_M = zeros(RealT, nVars, nnodes_projection)
+    w_M_raw = zeros(RealT, nVars, nnodes_projection)
+    w_M = zeros(RealT, nVars, nnodes_projection)
+    f_M = zeros(RealT, nVars, nnodes_projection)
+    g_M = zeros(RealT, nVars, nnodes_projection)
+
+    tmp_MxM = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    tmp_MxN = zeros(RealT, nVars, nnodes_projection, nnodes_)
+    tmp_NxM = zeros(RealT, nVars, nnodes_, nnodes_projection)
+
+#@threaded for element in eachelement(dg, cache)
+for element in eachelement(dg, cache)
+
+                    factor = inverse_jacobian[element]
+# get element u_N
+for i in eachnode(dg)
+    u_node = get_node_vars(u, equations, dg, i, element)
+    for v in eachvariable(eq_relax)
+        u_N[v,i] = u_node[v]
+    end
+end
+# bring elemtn u_N to grid (M+1)x(M+1)
+
+multiply_dimensionwise!(u_M,interpolate_N_to_M,u_N)
+
+# compute nodal values of entropy variables w on the M grid
+for i in 1:nnodes_projection
+    u_cons = get_node_vars(u_M, eq_relax, dg, i)
+    w_ij   = cons2entropy(u_cons,eq_relax) 
+    set_node_vars!(w_M_raw,w_ij,eq_relax,dg,i)
+end
+# compute projection of w with M values down to N
+multiply_dimensionwise!(w_M,filter_modal_to_N,w_M_raw)
+
+#multiply_dimensionwise!(w_N,project_M_to_N,w_M)
+#multiply_dimensionwise!(w_M,interpolate_N_to_M,w_N)
+
+
+# compute nodal values of conservative f,g on the M grid
+for i in 1:nnodes_projection
+    w_i = get_node_vars(w_M, eq_relax, dg, i)
+    u_cons = entropy2cons(w_i, eq_relax)
+    f_cons = flux(u_cons,1,eq_relax)
+    set_node_vars!(f_M,f_cons,eq_relax,dg,i)
+end
+# compute projection of f with M values down to N, same for g
+multiply_dimensionwise!(f_N,project_M_to_N,f_M)
+#@assert nnodes_projection == nnodes(dg) 
+#for j in 1:nnodes_projection, i in 1:nnodes_projection
+#    u_cons = get_node_vars(u_N, eq_relax, dg, i, j)
+#    f_cons = flux(u_cons,1,eq_relax)
+#    set_node_vars!(f_N,f_cons,eq_relax,dg,i,j)
+#    g_cons = flux(u_cons,2,eq_relax)
+#    set_node_vars!(g_N,g_cons,eq_relax,dg,i,j)
+#end
+
+    for i in eachnode(dg)
+        u_node = get_node_vars(u, equations, dg, i, element)
+        # compute compressible Euler fluxes
+        vu = get_node_vars(f_N,eq_relax,dg,i)
+        u_base = get_block_components2(u_node, 1, equations)
+        new_u = factor*SVector(zero(u_node)..., vu...)
+        set_node_vars!(u, new_u, equations, dg, i, element)
+    end
+end
+return nothing
+end
+
 function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D, equations::JinXinEquations, dg, cache)
 
     # relaxation parameter

From 2f402d72e57d2b5cda13ad2aa5de98fe4e602f05 Mon Sep 17 00:00:00 2001
From: Marco <artianomarco97@gmail.com>
Date: Fri, 31 May 2024 14:52:28 +0200
Subject: [PATCH 05/13] minor changes, debugging

---
 examples/tree_2d_dgsem/elixir_jin_xin_euler.jl | 2 +-
 src/time_integration/methods_IMEXJinXin.jl     | 6 ++++++
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
index 969e718d2d..6d4894d81e 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
@@ -61,7 +61,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)#
 ###############################################################################
 # ODE solvers, callbacks etc.
 
-tspan = (0.0, 3.6)
+tspan = (0.0, 1.0)
 #tspan = (0.0, 1.0)
 ode = semidiscretize(semi, tspan)
 
diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index 2e8942e1cb..5ccb428637 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -362,6 +362,7 @@ function cycle_divide!(u,dt,semi,solver,cache,aii,equations,mesh::TreeMesh2D)
          relaxation_rate = equations.eps_relaxation
                 for element in eachelement(solver,cache)
                     factor = inverse_jacobian[element]
+                    factor = 1.0
                     for j in eachnode(solver),i in eachnode(solver)
                         for var in (nvars_base+1):(nvars_base*3)
                         u[var,i,j,element] = u[var,i,j,element]/(1.0+factor*dt/relaxation_rate*aii)    
@@ -379,6 +380,7 @@ function cycle_divide!(u,dt,semi,solver,cache,aii,equations,mesh::TreeMesh1D)
          relaxation_rate = equations.eps_relaxation
                 for element in eachelement(solver,cache)
                     factor = inverse_jacobian[element]
+                    factor = 1.0
                     for i in eachnode(solver)
                         for var in (nvars_base+1):(nvars_base*2)
                         u[var,i,element] = u[var,i,element]/(1.0+factor*dt/relaxation_rate*aii)    
@@ -404,6 +406,7 @@ function set_cons_var_to_zero!(u,semi,solver,cache,equations, mesh::TreeMesh2D)
     @unpack inverse_jacobian = cache.elements
                 for element in eachelement(solver, cache)    
                     factor = inverse_jacobian[element]
+                    factor = 1.0
                     for j in eachnode(solver), i in eachnode(solver)
                         for var in 1:nvars_base
                            u_wrap[var,i,j,element] = 0.0
@@ -423,6 +426,7 @@ function set_cons_var_to_zero!(u,semi,solver,cache,equations, mesh::TreeMesh1D)
     @unpack inverse_jacobian = cache.elements
                 for element in eachelement(solver, cache)    
                     factor = inverse_jacobian[element]
+                    factor = 1.0
                     for i in eachnode(solver)
                         for var in 1:nvars_base
                            u_wrap[var,i,element] = 0.0
@@ -466,6 +470,7 @@ function perform_projection_sourceterm!(u, dt, mesh::TreeMesh1D, equations::JinX
 for element in eachelement(dg, cache)
 
                     factor = inverse_jacobian[element]
+                    factor = 1.0
 # get element u_N
 for i in eachnode(dg)
     u_node = get_node_vars(u, equations, dg, i, element)
@@ -551,6 +556,7 @@ function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D, equations::JinX
 for element in eachelement(dg, cache)
 
                     factor = inverse_jacobian[element]
+                    factor = 1.0
 # get element u_N
 for j in eachnode(dg), i in eachnode(dg)
     u_node = get_node_vars(u, equations, dg, i, j, element)

From fa7e44ba9f8bfc58ebcc8d406e393516d3c4579b Mon Sep 17 00:00:00 2001
From: Marco Artiano <artianomarco97@gmail.com>
Date: Sun, 2 Jun 2024 12:23:14 +0200
Subject: [PATCH 06/13] Time Integrator debugged

---
 examples/tree_2d_dgsem/elixir_jin_xin_euler.jl |  2 +-
 src/time_integration/methods_IMEXJinXin.jl     | 14 ++++++--------
 2 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
index 6d4894d81e..969e718d2d 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
@@ -61,7 +61,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)#
 ###############################################################################
 # ODE solvers, callbacks etc.
 
-tspan = (0.0, 1.0)
+tspan = (0.0, 3.6)
 #tspan = (0.0, 1.0)
 ode = semidiscretize(semi, tspan)
 
diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index 5ccb428637..c21a98fa58 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -250,11 +250,9 @@ function solve!(integrator::SimpleIntegratorIMEX)
                 #Ui = (ui;vi)
                 #u1 = un
                 #v1 = vn - -dt/epsilon A2_{11} (v1 - f(u1)) 
-              @. integrator.u1 .= integrator.u  #u1 = v1 = un
-                
-              @. integrator.fu1 .= integrator.u1
+              @. integrator.u1 = integrator.u  #u1 = v1 = un
+              @. integrator.fu1 = integrator.u1
                  wrap_and_perform_projection!(integrator.fu1,integrator.dt,mesh,equations,solver,cache)  # compute f(u1)
-
               @. integrator.u1 = integrator.u1 + integrator.dt/relaxation_rate*alg.A2[1,1]*integrator.fu1 # v1 = vn + dt/eps*A2_11 f(u1)
                 
                 divide_relaxed_var!(integrator.u1,integrator.dt,semi,solver,cache,alg.A2[1,1],equations,mesh)  # v1 = (vn + dt/eps*A2_11 f(u1))/(1 + dt/eps A2_11)
@@ -362,7 +360,7 @@ function cycle_divide!(u,dt,semi,solver,cache,aii,equations,mesh::TreeMesh2D)
          relaxation_rate = equations.eps_relaxation
                 for element in eachelement(solver,cache)
                     factor = inverse_jacobian[element]
-                    factor = 1.0
+                    #factor = 1.0
                     for j in eachnode(solver),i in eachnode(solver)
                         for var in (nvars_base+1):(nvars_base*3)
                         u[var,i,j,element] = u[var,i,j,element]/(1.0+factor*dt/relaxation_rate*aii)    
@@ -406,7 +404,7 @@ function set_cons_var_to_zero!(u,semi,solver,cache,equations, mesh::TreeMesh2D)
     @unpack inverse_jacobian = cache.elements
                 for element in eachelement(solver, cache)    
                     factor = inverse_jacobian[element]
-                    factor = 1.0
+                 #   factor = 1.0
                     for j in eachnode(solver), i in eachnode(solver)
                         for var in 1:nvars_base
                            u_wrap[var,i,j,element] = 0.0
@@ -556,7 +554,7 @@ function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D, equations::JinX
 for element in eachelement(dg, cache)
 
                     factor = inverse_jacobian[element]
-                    factor = 1.0
+                  #  factor = 1.0
 # get element u_N
 for j in eachnode(dg), i in eachnode(dg)
     u_node = get_node_vars(u, equations, dg, i, j, element)
@@ -607,7 +605,7 @@ multiply_dimensionwise!(g_N,project_M_to_N,g_M,tmp_NxM)
         vu = get_node_vars(f_N,eq_relax,dg,i,j)
         wu = get_node_vars(g_N,eq_relax,dg,i,j)
         u_base = get_block_components2(u_node, 1, equations)
-        new_u = factor*SVector(zero(u_node)..., vu..., wu...)
+        new_u = factor*SVector(zero(u_base)..., vu..., wu...)
         set_node_vars!(u, new_u, equations, dg, i, j, element)
     end
 end

From 39d7cce4e1e611108a79783f469ffc25aef5bb15 Mon Sep 17 00:00:00 2001
From: Marco Artiano <artianomarco97@gmail.com>
Date: Sun, 2 Jun 2024 13:01:39 +0200
Subject: [PATCH 07/13] experimenting aand 1D

---
 .../tree_1d_dgsem/elixir_jin_xin_burgers.jl   |  2 +-
 .../tree_2d_dgsem/elixir_jin_xin_euler.jl     |  2 +-
 .../elixir_jin_xin_euler_density_wave.jl      | 93 +++++++++++++++++++
 .../jin_xin_compressible_euler_2d.jl          |  1 +
 4 files changed, 96 insertions(+), 2 deletions(-)
 create mode 100644 examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl

diff --git a/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl b/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
index 134980a633..b2f9d7d555 100644
--- a/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
+++ b/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
@@ -5,7 +5,7 @@ using Trixi
 ###############################################################################
 # semidiscretization of the (inviscid) Burgers' equation
 epsilon_relaxation = 1.0e-6
-a1 = 10.0
+a1 = 3.0
 
 equations_base = InviscidBurgersEquation1D()
 velocities = (SVector(a1),)
diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
index 969e718d2d..3b686d20d0 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
@@ -32,7 +32,7 @@ initial_condition = Trixi.InitialConditionJinXin(initial_condition_kelvin_helmho
 polydeg = 3
 polydeg_cutoff = 3
 #basis = GaussLegendreBasis(polydeg; polydeg_projection = polydeg, polydeg_cutoff = polydeg_cutoff)
-basis = LobattoLegendreBasis(polydeg; polydeg_projection = 3)
+basis = LobattoLegendreBasis(polydeg; polydeg_projection = 6)
 solver = DGSEM(basis, Trixi.flux_upwind)
 #solver = DGSEM(basis, Trixi.flux_upwind, VolumeIntegralWeakFormProjection())
 #solver = DGSEM(basis, Trixi.flux_upwind, VolumeIntegralWeakForm())
diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
new file mode 100644
index 0000000000..7dbc33a670
--- /dev/null
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
@@ -0,0 +1,93 @@
+
+using OrdinaryDiffEq
+using Trixi
+using LinearAlgebra
+
+###############################################################################
+# semidiscretization of the compressible Euler equations
+
+epsilon_relaxation = 1.0e-6
+a1 = a2 = a3 = a4 = 30.0
+b1 = b2 = b3 = b4 = 30.0
+
+equations_base = CompressibleEulerEquations2D(1.4)
+velocities = (SVector(a1, a2, a3, a4), SVector(b1, b2, b3, b4))
+equations = JinXinEquations(equations_base, epsilon_relaxation, velocities)
+
+function initial_condition_density_wave(x, t, equations::CompressibleEulerEquations2D)
+    v1 = 0.1
+    v2 = 0.2
+    rho = 1 + 0.98 * sinpi(2 * (x[1] + x[2] - t * (v1 + v2)))
+    p = 20
+    return prim2cons(SVector(rho, v1, v2, p),equations)
+end
+
+initial_condition = Trixi.InitialConditionJinXin(initial_condition_density_wave)
+polydeg = 1
+#basis = LobattoLegendreBasis(polydeg; polydeg_projection = 0)
+basis = LobattoLegendreBasis(polydeg)
+
+volume_integral = VolumeIntegralWeakForm()
+solver = DGSEM(basis, Trixi.flux_upwind,VolumeIntegralWeakForm())
+#solver = DGSEM(basis, Trixi.flux_upwind)
+
+# solver = DGSEM(polydeg = 5, surface_flux = flux_central)
+
+coordinates_min = (-1.0, -1.0)
+coordinates_max = (1.0, 1.0)
+mesh = TreeMesh(coordinates_min, coordinates_max,
+                initial_refinement_level = 6,
+                n_cells_max = 30_000)
+
+                semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)#,source_terms=source_terms_JinXin_Relaxation)
+
+
+# @info "Create semi..."
+# semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)
+
+# @info "Compute Jacobian..."
+# J = jacobian_ad_forward(semi)
+
+# @info "Compute eigenvalues..."
+# λ = eigvals(J)
+
+# @info "max real part" maximum(real.(λ))
+# # @info "Plot spectrum..."
+# # scatter(real.(λ), imag.(λ), label="central flux")
+# wololo
+
+###############################################################################
+# ODE solvers, callbacks etc.
+
+tspan = (0.0, 2.0)
+ode = semidiscretize(semi, tspan)
+
+summary_callback = SummaryCallback()
+
+analysis_interval = 100 * 20
+analysis_callback = AnalysisCallback(semi, interval = analysis_interval)
+
+alive_callback = AliveCallback(analysis_interval = analysis_interval)
+
+save_solution = SaveSolutionCallback(interval = 100,
+                                     save_initial_solution = true,
+                                     save_final_solution = true,
+                                     solution_variables = cons2prim)
+
+stepsize_callback = StepsizeCallback(cfl = 0.25)
+
+callbacks = CallbackSet(summary_callback,
+                        analysis_callback, alive_callback,
+                        # save_solution,
+                        stepsize_callback)
+
+###############################################################################
+# run the simulation
+stage_limiter! = PositivityPreservingLimiterZhangShu(thresholds=(5.0e-6, 5.0e-6),
+                                                     variables=(Trixi.density, pressure))
+#sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
+#sol = Trixi.solve(ode, Trixi.SimpleIMEX(), 
+sol = solve(ode, SSPRK33(stage_limiter!),
+dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
+            save_everystep = false, callback = callbacks);
+summary_callback() # print the timer summary
diff --git a/src/equations/jin_xin_compressible_euler_2d.jl b/src/equations/jin_xin_compressible_euler_2d.jl
index 7c1e8aaa79..660c08d4ae 100644
--- a/src/equations/jin_xin_compressible_euler_2d.jl
+++ b/src/equations/jin_xin_compressible_euler_2d.jl
@@ -229,6 +229,7 @@ end
 
 # Convert conservative variables to entropy variables
 @inline cons2entropy(u, equations::JinXinEquations) = u
+@inline entropy2cons(u, equations::JinXinEquations) = u
 
 @inline prim2cons(u, equations::JinXinEquations) = u
 end # @muladd

From 2a65d0ddb2dfae486552b794b423853eb19af58a Mon Sep 17 00:00:00 2001
From: Marco Artiano <artianomarco97@gmail.com>
Date: Sun, 2 Jun 2024 19:41:29 +0200
Subject: [PATCH 08/13] fixed 1D

---
 examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl       |  8 ++++----
 .../tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl | 10 +++++-----
 src/time_integration/methods_IMEXJinXin.jl             |  2 +-
 3 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl b/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
index b2f9d7d555..769862314f 100644
--- a/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
+++ b/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
@@ -4,8 +4,8 @@ using Trixi
 
 ###############################################################################
 # semidiscretization of the (inviscid) Burgers' equation
-epsilon_relaxation = 1.0e-6
-a1 = 3.0
+epsilon_relaxation = 1.0e-4
+a1 = 9.0
 
 equations_base = InviscidBurgersEquation1D()
 velocities = (SVector(a1),)
@@ -16,8 +16,8 @@ function initial_condition_linear_stability(x, t, equation::InviscidBurgersEquat
     return prim2cons(SVector(u),equations)
 end
 
-basis = LobattoLegendreBasis(3)
-solver = DGSEM(basis,Trixi.flux_upwind)
+basis = LobattoLegendreBasis(3; polydeg_projection = 12, polydeg_cutoff = 3)
+solver = DGSEM(basis,Trixi.flux_upwind,VolumeIntegralWeakForm())
 
 
 coordinates_min = -1.0
diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
index 7dbc33a670..bfe67d864c 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
@@ -18,14 +18,14 @@ function initial_condition_density_wave(x, t, equations::CompressibleEulerEquati
     v1 = 0.1
     v2 = 0.2
     rho = 1 + 0.98 * sinpi(2 * (x[1] + x[2] - t * (v1 + v2)))
-    p = 20
+    p = 1
     return prim2cons(SVector(rho, v1, v2, p),equations)
 end
 
 initial_condition = Trixi.InitialConditionJinXin(initial_condition_density_wave)
-polydeg = 1
+polydeg = 3
 #basis = LobattoLegendreBasis(polydeg; polydeg_projection = 0)
-basis = LobattoLegendreBasis(polydeg)
+basis = LobattoLegendreBasis(polydeg; polydeg_projection = 3)
 
 volume_integral = VolumeIntegralWeakForm()
 solver = DGSEM(basis, Trixi.flux_upwind,VolumeIntegralWeakForm())
@@ -86,8 +86,8 @@ callbacks = CallbackSet(summary_callback,
 stage_limiter! = PositivityPreservingLimiterZhangShu(thresholds=(5.0e-6, 5.0e-6),
                                                      variables=(Trixi.density, pressure))
 #sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-#sol = Trixi.solve(ode, Trixi.SimpleIMEX(), 
-sol = solve(ode, SSPRK33(stage_limiter!),
+sol = Trixi.solve(ode, Trixi.SimpleIMEX(), 
+#sol = solve(ode, SSPRK33(stage_limiter!),
 dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
             save_everystep = false, callback = callbacks);
 summary_callback() # print the timer summary
diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index c21a98fa58..fbba733c36 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -516,7 +516,7 @@ multiply_dimensionwise!(f_N,project_M_to_N,f_M)
         # compute compressible Euler fluxes
         vu = get_node_vars(f_N,eq_relax,dg,i)
         u_base = get_block_components2(u_node, 1, equations)
-        new_u = factor*SVector(zero(u_node)..., vu...)
+        new_u = factor*SVector(zero(u_base)..., vu...)
         set_node_vars!(u, new_u, equations, dg, i, element)
     end
 end

From 821cf85448b808a81bbdb818332dbfe9e64baef0 Mon Sep 17 00:00:00 2001
From: Marco <artianomarco97@gmail.com>
Date: Mon, 3 Jun 2024 13:44:39 +0200
Subject: [PATCH 09/13] minor changes

---
 .../elixir_jin_xin_euler_density_wave.jl      | 71 +++++++++++++++++++
 .../elixir_jin_xin_euler_density_wave.jl      |  9 ++-
 src/time_integration/methods_IMEXJinXin.jl    |  2 +-
 3 files changed, 76 insertions(+), 6 deletions(-)
 create mode 100644 examples/tree_1d_dgsem/elixir_jin_xin_euler_density_wave.jl

diff --git a/examples/tree_1d_dgsem/elixir_jin_xin_euler_density_wave.jl b/examples/tree_1d_dgsem/elixir_jin_xin_euler_density_wave.jl
new file mode 100644
index 0000000000..b4366cbacc
--- /dev/null
+++ b/examples/tree_1d_dgsem/elixir_jin_xin_euler_density_wave.jl
@@ -0,0 +1,71 @@
+
+using OrdinaryDiffEq
+using Trixi
+
+###############################################################################
+# semidiscretization of the compressible Euler equations
+
+
+epsilon_relaxation = 1.0e-6
+
+equations_base = CompressibleEulerEquations1D(1.4)
+velocities = (SVector(a1, a2, a3),)
+equations = JinXinEquations(equations_base, epsilon_relaxation, velocities)
+
+function initial_condition_density_wave(x, t, equations::CompressibleEulerEquations1D)
+    v1 = 0.1
+    rho = 1 + 0.98 * sinpi(2 * (x[1] - t * v1))
+    p = 20
+    return prim2cons(SVector(rho, v1, p),equations)
+end
+
+
+initial_condition = Trixi.InitialConditionJinXin(initial_condition_density_wave)
+polydeg = 3
+#basis = LobattoLegendreBasis(polydeg; polydeg_projection = 0)
+basis = LobattoLegendreBasis(polydeg; polydeg_projection = 6)
+
+volume_integral = VolumeIntegralWeakForm()
+#solver = DGSEM(basis, Trixi.flux_upwind,VolumeIntegralWeakForm())
+solver = DGSEM(basis, Trixi.flux_upwind)
+
+coordinates_min = -1.0
+coordinates_max = 1.0
+mesh = TreeMesh(coordinates_min, coordinates_max,
+                initial_refinement_level = 2,
+                n_cells_max = 30_000)
+
+semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)
+
+###############################################################################
+# ODE solvers, callbacks etc.
+
+tspan = (0.0, 2.0)
+ode = semidiscretize(semi, tspan)
+
+summary_callback = SummaryCallback()
+
+analysis_interval = 2000
+analysis_callback = AnalysisCallback(semi, interval = analysis_interval)
+
+
+alive_callback = AliveCallback(analysis_interval = analysis_interval)
+save_solution = SaveSolutionCallback(interval = 100,
+                                     save_initial_solution = true,
+                                     save_final_solution = true,
+                                     solution_variables = cons2prim)
+
+stepsize_callback = StepsizeCallback(cfl = 0.8)
+
+callbacks = CallbackSet(summary_callback,
+                        analysis_callback, alive_callback,
+                        save_solution,
+                        stepsize_callback)
+
+###############################################################################
+# run the simulation
+
+sol = Trixi.solve(ode, Trixi.SimpleIMEX(),
+            dt = 1e-3, # solve needs some value here but it will be overwritten by the stepsize_callback
+            save_everystep = false, callback = callbacks);
+summary_callback() # print the timer summary
\ No newline at end of file
diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
index bfe67d864c..4c2ea3800d 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
@@ -1,4 +1,3 @@
-
 using OrdinaryDiffEq
 using Trixi
 using LinearAlgebra
@@ -25,11 +24,11 @@ end
 initial_condition = Trixi.InitialConditionJinXin(initial_condition_density_wave)
 polydeg = 3
 #basis = LobattoLegendreBasis(polydeg; polydeg_projection = 0)
-basis = LobattoLegendreBasis(polydeg; polydeg_projection = 3)
+basis = LobattoLegendreBasis(polydeg; polydeg_projection = polydeg)
 
 volume_integral = VolumeIntegralWeakForm()
-solver = DGSEM(basis, Trixi.flux_upwind,VolumeIntegralWeakForm())
-#solver = DGSEM(basis, Trixi.flux_upwind)
+#solver = DGSEM(basis, Trixi.flux_upwind,VolumeIntegralWeakForm())
+solver = DGSEM(basis, Trixi.flux_upwind)
 
 # solver = DGSEM(polydeg = 5, surface_flux = flux_central)
 
@@ -74,7 +73,7 @@ save_solution = SaveSolutionCallback(interval = 100,
                                      save_final_solution = true,
                                      solution_variables = cons2prim)
 
-stepsize_callback = StepsizeCallback(cfl = 0.25)
+stepsize_callback = StepsizeCallback(cfl = 0.85)
 
 callbacks = CallbackSet(summary_callback,
                         analysis_callback, alive_callback,
diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index fbba733c36..82d54962b1 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -159,7 +159,7 @@ of type `SimpleAlgorithmSSP`.
 !!! warning "Experimental implementation"
     This is an experimental feature and may change in future releases.
 """
-function solve(ode::ODEProblem, alg = SimpleAlgorithmIMEX()::SimpleAlgorithmIMEX;
+function solve(ode::ODEProblem, alg::SimpleAlgorithmIMEX;
                dt, callback = nothing, kwargs...)
     u = copy(ode.u0)
     du1 = similar(u)

From 4faf1f3a2af02da9ca8fe74b40808dcfbd8d6e13 Mon Sep 17 00:00:00 2001
From: Marco <artianomarco97@gmail.com>
Date: Mon, 3 Jun 2024 14:32:24 +0200
Subject: [PATCH 10/13] Julia Formatting

---
 .../elixir_burgers_linear_stability.jl        |   2 +-
 .../tree_1d_dgsem/elixir_jin_xin_burgers.jl   |  11 +-
 .../elixir_jin_xin_euler_density_wave.jl      |  11 +-
 examples/tree_2d_dgsem/elixir_euler_ec.jl     |  18 +-
 ...ixir_euler_kelvin_helmholtz_instability.jl |   4 +-
 ...kelvin_helmholtz_instability_projection.jl |   2 +-
 .../tree_2d_dgsem/elixir_jin_xin_euler.jl     |  61 +-
 .../elixir_jin_xin_euler_density_wave.jl      |  17 +-
 src/auxiliary/precompile.jl                   |   8 +-
 src/callbacks_stage/modal_filter.jl           |  10 +-
 src/callbacks_stage/modal_filter_dg2d.jl      |   9 +-
 src/callbacks_stage/positivity_zhang_shu.jl   |   2 +-
 .../positivity_zhang_shu_dg2d.jl              |  97 +--
 src/callbacks_step/alive.jl                   |   2 +-
 src/callbacks_step/analysis_dg2d.jl           |   2 +-
 src/callbacks_step/averaging.jl               |   2 +-
 src/callbacks_step/glm_speed.jl               |   2 +-
 src/callbacks_step/save_restart.jl            |   2 +-
 src/callbacks_step/save_solution.jl           |   4 +-
 src/callbacks_step/steady_state.jl            |   2 +-
 src/callbacks_step/stepsize.jl                |   2 +-
 src/callbacks_step/time_series.jl             |   2 +-
 src/callbacks_step/visualization.jl           |   2 +-
 src/equations/equations.jl                    |   1 -
 .../jin_xin_compressible_euler_2d.jl          |  47 +-
 src/meshes/p4est_mesh.jl                      |   2 +-
 src/meshes/t8code_mesh.jl                     |  10 +-
 src/meshes/tree_mesh.jl                       |   2 +-
 .../semidiscretization_euler_gravity.jl       |   2 +-
 src/solvers/dg.jl                             |  12 +-
 src/solvers/dgsem/basis_gauss_legendre.jl     |  63 +-
 src/solvers/dgsem/basis_lobatto_legendre.jl   |  78 ++-
 src/solvers/dgsem_tree/dg_2d.jl               |  71 +-
 src/solvers/dgsem_tree/indicators.jl          |   6 +-
 src/solvers/dgsem_tree/subcell_limiters.jl    |   6 +-
 src/time_integration/methods_IMEXJinXin.jl    | 640 +++++++++---------
 test/test_dgmulti_1d.jl                       |  28 +-
 test/test_dgmulti_2d.jl                       | 122 ++--
 test/test_dgmulti_3d.jl                       |  52 +-
 test/test_mpi_p4est_2d.jl                     |   4 +-
 test/test_mpi_p4est_3d.jl                     |  16 +-
 test/test_mpi_t8code_2d.jl                    |   4 +-
 test/test_mpi_t8code_3d.jl                    |  12 +-
 test/test_mpi_tree.jl                         |  52 +-
 test/test_p4est_2d.jl                         |  70 +-
 test/test_p4est_3d.jl                         |  60 +-
 ...est_paper_self_gravitating_gas_dynamics.jl |  48 +-
 test/test_parabolic_1d.jl                     |  24 +-
 test/test_parabolic_2d.jl                     |  60 +-
 test/test_parabolic_3d.jl                     |  60 +-
 test/test_structured_1d.jl                    |  10 +-
 test/test_structured_2d.jl                    | 120 ++--
 test/test_structured_3d.jl                    |  24 +-
 test/test_t8code_2d.jl                        |  18 +-
 test/test_t8code_3d.jl                        |  24 +-
 test/test_threaded.jl                         |  44 +-
 test/test_tree_1d_euler.jl                    |  64 +-
 test/test_tree_1d_eulergravity.jl             |   4 +-
 test/test_tree_1d_eulermulti.jl               |   8 +-
 test/test_tree_1d_fdsbp.jl                    |  16 +-
 test/test_tree_1d_linearizedeuler.jl          |   6 +-
 test/test_tree_1d_mhd.jl                      |  44 +-
 test/test_tree_1d_shallowwater.jl             |  56 +-
 test/test_tree_2d_acoustics.jl                |  12 +-
 test/test_tree_2d_euler.jl                    | 148 ++--
 test/test_tree_2d_euleracoustics.jl           |   4 +-
 test/test_tree_2d_eulermulti.jl               |  32 +-
 test/test_tree_2d_eulerpolytropic.jl          |   4 +-
 test/test_tree_2d_fdsbp.jl                    |  20 +-
 test/test_tree_2d_hypdiff.jl                  |  16 +-
 test/test_tree_2d_linearizedeuler.jl          |   8 +-
 test/test_tree_2d_mhd.jl                      |  40 +-
 test/test_tree_2d_shallowwater.jl             |  44 +-
 test/test_tree_3d_euler.jl                    |  78 +--
 test/test_tree_3d_eulergravity.jl             |   4 +-
 test/test_tree_3d_fdsbp.jl                    |  12 +-
 test/test_tree_3d_hypdiff.jl                  |  12 +-
 test/test_tree_3d_linearizedeuler.jl          |   4 +-
 test/test_tree_3d_mhd.jl                      |  28 +-
 test/test_unit.jl                             |  10 +-
 test/test_unstructured_2d.jl                  |  76 +--
 81 files changed, 1429 insertions(+), 1387 deletions(-)

diff --git a/examples/tree_1d_dgsem/elixir_burgers_linear_stability.jl b/examples/tree_1d_dgsem/elixir_burgers_linear_stability.jl
index e8ee9311a2..5e547e3502 100644
--- a/examples/tree_1d_dgsem/elixir_burgers_linear_stability.jl
+++ b/examples/tree_1d_dgsem/elixir_burgers_linear_stability.jl
@@ -51,4 +51,4 @@ callbacks = CallbackSet(summary_callback,
 sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
             dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
             save_everystep = false, callback = callbacks);
-summary_callback() # print the timer summary
\ No newline at end of file
+summary_callback() # print the timer summary
diff --git a/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl b/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
index 769862314f..b6875fd81b 100644
--- a/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
+++ b/examples/tree_1d_dgsem/elixir_jin_xin_burgers.jl
@@ -9,16 +9,15 @@ a1 = 9.0
 
 equations_base = InviscidBurgersEquation1D()
 velocities = (SVector(a1),)
-equations = JinXinEquations(equations_base,epsilon_relaxation, velocities)
+equations = JinXinEquations(equations_base, epsilon_relaxation, velocities)
 function initial_condition_linear_stability(x, t, equation::InviscidBurgersEquation1D)
     k = 1
     u = 2 + sinpi(k * (x[1] - 0.7))
-    return prim2cons(SVector(u),equations)
+    return prim2cons(SVector(u), equations)
 end
 
 basis = LobattoLegendreBasis(3; polydeg_projection = 12, polydeg_cutoff = 3)
-solver = DGSEM(basis,Trixi.flux_upwind,VolumeIntegralWeakForm())
-
+solver = DGSEM(basis, Trixi.flux_upwind, VolumeIntegralWeakForm())
 
 coordinates_min = -1.0
 coordinates_max = 1.0
@@ -52,6 +51,6 @@ callbacks = CallbackSet(summary_callback,
 # run the simulation
 
 sol = Trixi.solve(ode, Trixi.SimpleIMEX(),
-            dt = 1.0e-3, # solve needs some value here but it will be overwritten by the stepsize_callback
-            save_everystep = false, callback = callbacks,maxiters=1e7);
+                  dt = 1.0e-3, # solve needs some value here but it will be overwritten by the stepsize_callback
+                  save_everystep = false, callback = callbacks, maxiters = 1e7);
 summary_callback() # print the timer summary
diff --git a/examples/tree_1d_dgsem/elixir_jin_xin_euler_density_wave.jl b/examples/tree_1d_dgsem/elixir_jin_xin_euler_density_wave.jl
index b4366cbacc..10ba2386c5 100644
--- a/examples/tree_1d_dgsem/elixir_jin_xin_euler_density_wave.jl
+++ b/examples/tree_1d_dgsem/elixir_jin_xin_euler_density_wave.jl
@@ -5,7 +5,6 @@ using Trixi
 ###############################################################################
 # semidiscretization of the compressible Euler equations
 
-
 epsilon_relaxation = 1.0e-6
 
 equations_base = CompressibleEulerEquations1D(1.4)
@@ -16,10 +15,9 @@ function initial_condition_density_wave(x, t, equations::CompressibleEulerEquati
     v1 = 0.1
     rho = 1 + 0.98 * sinpi(2 * (x[1] - t * v1))
     p = 20
-    return prim2cons(SVector(rho, v1, p),equations)
+    return prim2cons(SVector(rho, v1, p), equations)
 end
 
-
 initial_condition = Trixi.InitialConditionJinXin(initial_condition_density_wave)
 polydeg = 3
 #basis = LobattoLegendreBasis(polydeg; polydeg_projection = 0)
@@ -48,7 +46,6 @@ summary_callback = SummaryCallback()
 analysis_interval = 2000
 analysis_callback = AnalysisCallback(semi, interval = analysis_interval)
 
-
 alive_callback = AliveCallback(analysis_interval = analysis_interval)
 save_solution = SaveSolutionCallback(interval = 100,
                                      save_initial_solution = true,
@@ -66,6 +63,6 @@ callbacks = CallbackSet(summary_callback,
 # run the simulation
 
 sol = Trixi.solve(ode, Trixi.SimpleIMEX(),
-            dt = 1e-3, # solve needs some value here but it will be overwritten by the stepsize_callback
-            save_everystep = false, callback = callbacks);
-summary_callback() # print the timer summary
\ No newline at end of file
+                  dt = 1e-3, # solve needs some value here but it will be overwritten by the stepsize_callback
+                  save_everystep = false, callback = callbacks);
+summary_callback() # print the timer summary
diff --git a/examples/tree_2d_dgsem/elixir_euler_ec.jl b/examples/tree_2d_dgsem/elixir_euler_ec.jl
index 7a9c5269a9..55e03a0bf4 100644
--- a/examples/tree_2d_dgsem/elixir_euler_ec.jl
+++ b/examples/tree_2d_dgsem/elixir_euler_ec.jl
@@ -8,12 +8,12 @@ equations = CompressibleEulerEquations2D(1.4)
 
 seed!(1)
 function initial_condition_random_field(x, t, equations::CompressibleEulerEquations2D)
-amplitude = 1.5
-rho = 2 + amplitude * rand() 
-v1 = -3.1 + amplitude * rand()
-v2 = 1.3 + amplitude * rand() 
-p = 7.54 + amplitude * rand()
-return prim2cons(SVector(rho, v1, v2, p), equations)
+    amplitude = 1.5
+    rho = 2 + amplitude * rand()
+    v1 = -3.1 + amplitude * rand()
+    v2 = 1.3 + amplitude * rand()
+    p = 7.54 + amplitude * rand()
+    return prim2cons(SVector(rho, v1, v2, p), equations)
 end
 # initial_condition = initial_condition_weak_blast_wave
 initial_condition = initial_condition_random_field
@@ -69,11 +69,13 @@ callbacks = CallbackSet(summary_callback,
 
 # Create modal filter and filter initial condition
 modal_filter = ModalFilter(solver; polydeg_cutoff = 3,
-                                   cons2filter = cons2prim, filter2cons = prim2cons)
+                           cons2filter = cons2prim, filter2cons = prim2cons)
 modal_filter(ode.u0, semi)
 
 # sol = solve(ode, CarpenterKennedy2N54(; williamson_condition = false),
-sol = solve(ode, CarpenterKennedy2N54(; stage_limiter! = modal_filter, williamson_condition = false),
+sol = solve(ode,
+            CarpenterKennedy2N54(; stage_limiter! = modal_filter,
+                                 williamson_condition = false),
             dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
             save_everystep = false, callback = callbacks);
 summary_callback() # print the timer summary
diff --git a/examples/tree_2d_dgsem/elixir_euler_kelvin_helmholtz_instability.jl b/examples/tree_2d_dgsem/elixir_euler_kelvin_helmholtz_instability.jl
index 8835f5cccf..39370e28eb 100644
--- a/examples/tree_2d_dgsem/elixir_euler_kelvin_helmholtz_instability.jl
+++ b/examples/tree_2d_dgsem/elixir_euler_kelvin_helmholtz_instability.jl
@@ -33,7 +33,7 @@ end
 initial_condition = initial_condition_kelvin_helmholtz_instability
 
 surface_flux = flux_hllc
-volume_flux  = flux_ranocha
+volume_flux = flux_ranocha
 polydeg = 3
 basis = LobattoLegendreBasis(polydeg)
 indicator_sc = IndicatorHennemannGassner(equations, basis,
@@ -67,7 +67,7 @@ analysis_callback = AnalysisCallback(semi, interval = analysis_interval)
 
 alive_callback = AliveCallback(analysis_interval = analysis_interval)
 
-save_solution = SaveSolutionCallback(interval=1000,
+save_solution = SaveSolutionCallback(interval = 1000,
                                      save_initial_solution = true,
                                      save_final_solution = true,
                                      solution_variables = cons2prim)
diff --git a/examples/tree_2d_dgsem/elixir_euler_kelvin_helmholtz_instability_projection.jl b/examples/tree_2d_dgsem/elixir_euler_kelvin_helmholtz_instability_projection.jl
index 5906f094e9..7bcd830d70 100644
--- a/examples/tree_2d_dgsem/elixir_euler_kelvin_helmholtz_instability_projection.jl
+++ b/examples/tree_2d_dgsem/elixir_euler_kelvin_helmholtz_instability_projection.jl
@@ -69,7 +69,7 @@ analysis_callback = AnalysisCallback(semi, interval = analysis_interval)
 
 alive_callback = AliveCallback(analysis_interval = analysis_interval)
 
-save_solution = SaveSolutionCallback(interval=1000,
+save_solution = SaveSolutionCallback(interval = 1000,
                                      save_initial_solution = true,
                                      save_final_solution = true,
                                      solution_variables = cons2prim)
diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
index 3b686d20d0..b8dbeeb53e 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler.jl
@@ -12,18 +12,19 @@ equations_base = CompressibleEulerEquations2D(1.4)
 velocities = (SVector(a1, a2, a3, a4), SVector(b1, b2, b3, b4))
 equations = JinXinEquations(equations_base, epsilon_relaxation, velocities)
 
-function initial_condition_kelvin_helmholtz_instability(x, t, equations::CompressibleEulerEquations2D)
-  # change discontinuity to tanh
-  # typical resolution 128^2, 256^2
-  # domain size is [-1,+1]^2
-  slope = 15
-  amplitude = 0.02
-  B = tanh(slope * x[2] + 7.5) - tanh(slope * x[2] - 7.5)
-  rho = 0.5 + 0.75 * B
-  v1 = 0.5 * (B - 1)
-  v2 = 0.1 * sin(2 * pi * x[1])
-  p = 1.0
-  return prim2cons(SVector(rho, v1, v2, p), equations)
+function initial_condition_kelvin_helmholtz_instability(x, t,
+                                                        equations::CompressibleEulerEquations2D)
+    # change discontinuity to tanh
+    # typical resolution 128^2, 256^2
+    # domain size is [-1,+1]^2
+    slope = 15
+    amplitude = 0.02
+    B = tanh(slope * x[2] + 7.5) - tanh(slope * x[2] - 7.5)
+    rho = 0.5 + 0.75 * B
+    v1 = 0.5 * (B - 1)
+    v2 = 0.1 * sin(2 * pi * x[1])
+    p = 1.0
+    return prim2cons(SVector(rho, v1, v2, p), equations)
 end
 
 #initial_condition = initial_condition_constant
@@ -50,11 +51,11 @@ solver = DGSEM(basis, Trixi.flux_upwind)
 #solver = DGSEM(basis, surface_flux, volume_integral)
 
 coordinates_min = (-1.0, -1.0)
-coordinates_max = ( 1.0,  1.0)
+coordinates_max = (1.0, 1.0)
 
 mesh = TreeMesh(coordinates_min, coordinates_max,
-                initial_refinement_level=6,
-                n_cells_max=1_000_000)
+                initial_refinement_level = 6,
+                n_cells_max = 1_000_000)
 
 semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)#,source_terms=source_terms_JinXin_Relaxation)
 
@@ -68,32 +69,32 @@ ode = semidiscretize(semi, tspan)
 summary_callback = SummaryCallback()
 
 analysis_interval = 1000
-analysis_callback = AnalysisCallback(semi, interval=analysis_interval)
+analysis_callback = AnalysisCallback(semi, interval = analysis_interval)
 
-alive_callback = AliveCallback(analysis_interval=analysis_interval)
+alive_callback = AliveCallback(analysis_interval = analysis_interval)
 
-save_solution = SaveSolutionCallback(interval=1000,
-                                     save_initial_solution=true,
-                                     save_final_solution=true,
-                                     solution_variables=cons2prim)
+save_solution = SaveSolutionCallback(interval = 1000,
+                                     save_initial_solution = true,
+                                     save_final_solution = true,
+                                     solution_variables = cons2prim)
 
-stepsize_callback = StepsizeCallback(cfl=0.5)
+stepsize_callback = StepsizeCallback(cfl = 0.5)
 
 callbacks = CallbackSet(summary_callback,
                         analysis_callback, alive_callback,
-                        save_solution,stepsize_callback)
+                        save_solution, stepsize_callback)
 
 ###############################################################################
 # run the simulation
-stage_limiter! = PositivityPreservingLimiterZhangShu(thresholds=(5.0e-6, 5.0e-6),
-                                                     variables=(Trixi.density, pressure))
+stage_limiter! = PositivityPreservingLimiterZhangShu(thresholds = (5.0e-6, 5.0e-6),
+                                                     variables = (Trixi.density, pressure))
 
 #sol = solve(ode, CarpenterKennedy2N54(stage_limiter!,williamson_condition=false),
 #sol = solve(ode, SSPRK43(stage_limiter!),
 sol = Trixi.solve(ode, Trixi.SimpleIMEX(),
-#sol = solve(ode, SSPRK33(stage_limiter!),
-#sol = solve(ode, RDPK3SpFSAL49(),
-#sol = solve(ode, AutoTsit5(Rosenbrock23()),
-            dt=1.0e-3, # solve needs some value here but it will be overwritten by the stepsize_callback
-            save_everystep=false, callback=callbacks,maxiters=1e7);
+                  #sol = solve(ode, SSPRK33(stage_limiter!),
+                  #sol = solve(ode, RDPK3SpFSAL49(),
+                  #sol = solve(ode, AutoTsit5(Rosenbrock23()),
+                  dt = 1.0e-3, # solve needs some value here but it will be overwritten by the stepsize_callback
+                  save_everystep = false, callback = callbacks, maxiters = 1e7);
 summary_callback() # print the timer summary
diff --git a/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl b/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
index 4c2ea3800d..cb73066bdc 100644
--- a/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
+++ b/examples/tree_2d_dgsem/elixir_jin_xin_euler_density_wave.jl
@@ -18,7 +18,7 @@ function initial_condition_density_wave(x, t, equations::CompressibleEulerEquati
     v2 = 0.2
     rho = 1 + 0.98 * sinpi(2 * (x[1] + x[2] - t * (v1 + v2)))
     p = 1
-    return prim2cons(SVector(rho, v1, v2, p),equations)
+    return prim2cons(SVector(rho, v1, v2, p), equations)
 end
 
 initial_condition = Trixi.InitialConditionJinXin(initial_condition_density_wave)
@@ -38,8 +38,7 @@ mesh = TreeMesh(coordinates_min, coordinates_max,
                 initial_refinement_level = 6,
                 n_cells_max = 30_000)
 
-                semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)#,source_terms=source_terms_JinXin_Relaxation)
-
+semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)#,source_terms=source_terms_JinXin_Relaxation)
 
 # @info "Create semi..."
 # semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver)
@@ -82,11 +81,11 @@ callbacks = CallbackSet(summary_callback,
 
 ###############################################################################
 # run the simulation
-stage_limiter! = PositivityPreservingLimiterZhangShu(thresholds=(5.0e-6, 5.0e-6),
-                                                     variables=(Trixi.density, pressure))
+stage_limiter! = PositivityPreservingLimiterZhangShu(thresholds = (5.0e-6, 5.0e-6),
+                                                     variables = (Trixi.density, pressure))
 #sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-sol = Trixi.solve(ode, Trixi.SimpleIMEX(), 
-#sol = solve(ode, SSPRK33(stage_limiter!),
-dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
-            save_everystep = false, callback = callbacks);
+sol = Trixi.solve(ode, Trixi.SimpleIMEX(),
+                  #sol = solve(ode, SSPRK33(stage_limiter!),
+                  dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
+                  save_everystep = false, callback = callbacks);
 summary_callback() # print the timer summary
diff --git a/src/auxiliary/precompile.jl b/src/auxiliary/precompile.jl
index 860dc95a9d..cf006fcb9f 100644
--- a/src/auxiliary/precompile.jl
+++ b/src/auxiliary/precompile.jl
@@ -306,7 +306,7 @@ function _precompile_manual_()
     # Nevertheless, we can still precompile methods used to construct the bases.
     #Base.precompile(Tuple{Type{LobattoLegendreBasis}, Int})
     for RealT in (Float64,)
-    #    Base.precompile(Tuple{Type{LobattoLegendreBasis}, RealT, Int})
+        #    Base.precompile(Tuple{Type{LobattoLegendreBasis}, RealT, Int})
         @assert Base.precompile(Tuple{typeof(Trixi.calc_dhat), Vector{RealT},
                                       Vector{RealT}})
         @assert Base.precompile(Tuple{typeof(Trixi.calc_dsplit), Vector{RealT},
@@ -340,9 +340,9 @@ function _precompile_manual_()
     for RealT in (Float64,), polydeg in 1:7
         nnodes_ = polydeg + 1
         basis_type = basis_type_dgsem(RealT, nnodes_)
-#        @assert Base.precompile(Tuple{typeof(Trixi.MortarL2), basis_type})
-#        @assert Base.precompile(Tuple{Type{Trixi.SolutionAnalyzer}, basis_type})
-#        @assert Base.precompile(Tuple{Type{Trixi.AdaptorL2}, basis_type})
+        #        @assert Base.precompile(Tuple{typeof(Trixi.MortarL2), basis_type})
+        #        @assert Base.precompile(Tuple{Type{Trixi.SolutionAnalyzer}, basis_type})
+        #        @assert Base.precompile(Tuple{Type{Trixi.AdaptorL2}, basis_type})
     end
 
     # Constructors: callbacks
diff --git a/src/callbacks_stage/modal_filter.jl b/src/callbacks_stage/modal_filter.jl
index 86094e8cdb..13fb87e2e1 100644
--- a/src/callbacks_stage/modal_filter.jl
+++ b/src/callbacks_stage/modal_filter.jl
@@ -22,7 +22,7 @@ struct ModalFilter{RealT, Cons2Filter, Filter2Cons}
 end
 
 function ModalFilter(dg; polydeg_cutoff::Integer, cons2filter = cons2cons,
-                         filter2cons = cons2cons)
+                     filter2cons = cons2cons)
     RealT = real(dg)
     if dg.basis isa LobattoLegendreBasis
         nodes_cutoff, _ = gauss_lobatto_nodes_weights(polydeg_cutoff)
@@ -36,7 +36,8 @@ function ModalFilter(dg; polydeg_cutoff::Integer, cons2filter = cons2cons,
 
     modal_filter = ModalFilter{RealT,
                                typeof(cons2filter),
-                               typeof(filter2cons)}(cons2filter, filter2cons, filter_matrix)
+                               typeof(filter2cons)}(cons2filter, filter2cons,
+                                                    filter_matrix)
 end
 
 # Main function that applies the actual, mesh- and solver-specific filter
@@ -47,14 +48,15 @@ function (modal_filter::ModalFilter)(u_ode, semi::AbstractSemidiscretization)
     @trixi_timeit timer() "modal filter" begin
         # println("Applying modal filter")
         apply_modal_filter!(u, u, cons2filter, filter2cons, filter_matrix,
-                            mesh_equations_solver_cache(semi)...)  
+                            mesh_equations_solver_cache(semi)...)
     end
 
     return nothing
 end
 
 # This version is called as the stage limiter version of the filter
-function (modal_filter::ModalFilter)(u_ode, integrator, semi::AbstractSemidiscretization, t)
+function (modal_filter::ModalFilter)(u_ode, integrator,
+                                     semi::AbstractSemidiscretization, t)
     modal_filter(u_ode, semi)
 end
 
diff --git a/src/callbacks_stage/modal_filter_dg2d.jl b/src/callbacks_stage/modal_filter_dg2d.jl
index 1eb05bfec9..adc05d8158 100644
--- a/src/callbacks_stage/modal_filter_dg2d.jl
+++ b/src/callbacks_stage/modal_filter_dg2d.jl
@@ -19,15 +19,15 @@ function apply_modal_filter!(u_filtered, u, cons2filter, filter2cons, filter_mat
         # convert u to filter variables
         for j in eachnode(dg), i in eachnode(dg)
             u_node_cons = get_node_vars(u, equations, dg, i, j, element)
-            u_node_filter   = cons2filter(u_node_cons, equations)
+            u_node_filter = cons2filter(u_node_cons, equations)
             for v in eachvariable(equations)
-              u_element[v,i,j] = u_node_filter[v]
+                u_element[v, i, j] = u_node_filter[v]
             end
         end
 
         # Apply modal filter
         multiply_dimensionwise!(u_element_filtered, filter_matrix, u_element, tmp_NxN)
-    
+
         # compute nodal values of conservative variables from the projected entropy variables
         for j in eachnode(dg), i in eachnode(dg)
             u_node_filter = get_node_vars(u_element_filtered, equations, dg, i, j)
@@ -36,5 +36,4 @@ function apply_modal_filter!(u_filtered, u, cons2filter, filter2cons, filter_mat
         end
     end
 end
-
-end # @muladd
\ No newline at end of file
+end # @muladd
diff --git a/src/callbacks_stage/positivity_zhang_shu.jl b/src/callbacks_stage/positivity_zhang_shu.jl
index 5cd2bf4ea3..8ed3c3005e 100644
--- a/src/callbacks_stage/positivity_zhang_shu.jl
+++ b/src/callbacks_stage/positivity_zhang_shu.jl
@@ -35,7 +35,7 @@ function (limiter!::PositivityPreservingLimiterZhangShu)(u_ode, integrator,
     @trixi_timeit timer() "positivity-preserving limiter" begin
         #limiter_zhang_shu!(u, limiter!.thresholds, limiter!.variables,
         #                   mesh_equations_solver_cache(semi)...)
-        perform_idp_correction!(u, integrator.dt, mesh_equations_solver_cache(semi)...)  
+        perform_idp_correction!(u, integrator.dt, mesh_equations_solver_cache(semi)...)
     end
 end
 
diff --git a/src/callbacks_stage/positivity_zhang_shu_dg2d.jl b/src/callbacks_stage/positivity_zhang_shu_dg2d.jl
index 567217292a..ef924cc404 100644
--- a/src/callbacks_stage/positivity_zhang_shu_dg2d.jl
+++ b/src/callbacks_stage/positivity_zhang_shu_dg2d.jl
@@ -47,71 +47,71 @@ function limiter_zhang_shu!(u, threshold::Real, variable,
 
     return nothing
 end
-function perform_idp_correction!(u, dt, mesh::TreeMesh2D, equations::JinXinEquations, dg, cache)
-
-            # relaxation parameter
-            eps = equations.eps_relaxation
-            dt_ = dt
-            factor =1.0/ (eps + dt_)
-            eq_relax = equations.equations_base
-
-            # prepare local storage for projection
-            @unpack interpolate_N_to_M, project_M_to_N, filter_modal_to_N = dg.basis
-            nnodes_,nnodes_projection = size(project_M_to_N)
-            nVars = nvariables(eq_relax)
-            RealT = real(dg)
-            u_N = zeros(RealT, nVars, nnodes_, nnodes_)
-            w_N = zeros(RealT, nVars, nnodes_, nnodes_)
-            f_N = zeros(RealT, nVars, nnodes_, nnodes_)
-            g_N = zeros(RealT, nVars, nnodes_, nnodes_)
-            u_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
-            w_M_raw = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
-            w_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
-            f_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
-            g_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
-
-            tmp_MxM = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
-            tmp_MxN = zeros(RealT, nVars, nnodes_projection, nnodes_)
-            tmp_NxM = zeros(RealT, nVars, nnodes_, nnodes_projection)
-
- #@threaded for element in eachelement(dg, cache)
-  for element in eachelement(dg, cache)
+function perform_idp_correction!(u, dt, mesh::TreeMesh2D, equations::JinXinEquations,
+                                 dg, cache)
+
+    # relaxation parameter
+    eps = equations.eps_relaxation
+    dt_ = dt
+    factor = 1.0 / (eps + dt_)
+    eq_relax = equations.equations_base
+
+    # prepare local storage for projection
+    @unpack interpolate_N_to_M, project_M_to_N, filter_modal_to_N = dg.basis
+    nnodes_, nnodes_projection = size(project_M_to_N)
+    nVars = nvariables(eq_relax)
+    RealT = real(dg)
+    u_N = zeros(RealT, nVars, nnodes_, nnodes_)
+    w_N = zeros(RealT, nVars, nnodes_, nnodes_)
+    f_N = zeros(RealT, nVars, nnodes_, nnodes_)
+    g_N = zeros(RealT, nVars, nnodes_, nnodes_)
+    u_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    w_M_raw = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    w_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    f_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    g_M = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+
+    tmp_MxM = zeros(RealT, nVars, nnodes_projection, nnodes_projection)
+    tmp_MxN = zeros(RealT, nVars, nnodes_projection, nnodes_)
+    tmp_NxM = zeros(RealT, nVars, nnodes_, nnodes_projection)
+
+    #@threaded for element in eachelement(dg, cache)
+    for element in eachelement(dg, cache)
 
         # get element u_N
         for j in eachnode(dg), i in eachnode(dg)
             u_node = get_node_vars(u, equations, dg, i, j, element)
             for v in eachvariable(eq_relax)
-                u_N[v,i,j] = u_node[v]
+                u_N[v, i, j] = u_node[v]
             end
         end
         # bring elemtn u_N to grid (M+1)x(M+1)
-        multiply_dimensionwise!(u_M,interpolate_N_to_M,u_N,tmp_MxN)
-        
+        multiply_dimensionwise!(u_M, interpolate_N_to_M, u_N, tmp_MxN)
+
         # compute nodal values of entropy variables w on the M grid
         for j in 1:nnodes_projection, i in 1:nnodes_projection
             u_cons = get_node_vars(u_M, eq_relax, dg, i, j)
-            w_ij   = cons2entropy(u_cons,eq_relax) 
-            set_node_vars!(w_M_raw,w_ij,eq_relax,dg,i,j)
+            w_ij = cons2entropy(u_cons, eq_relax)
+            set_node_vars!(w_M_raw, w_ij, eq_relax, dg, i, j)
         end
         # compute projection of w with M values down to N
-        multiply_dimensionwise!(w_M,filter_modal_to_N,w_M_raw,tmp_MxM)
+        multiply_dimensionwise!(w_M, filter_modal_to_N, w_M_raw, tmp_MxM)
 
         #multiply_dimensionwise!(w_N,project_M_to_N,w_M)
         #multiply_dimensionwise!(w_M,interpolate_N_to_M,w_N)
 
-
         # compute nodal values of conservative f,g on the M grid
         for j in 1:nnodes_projection, i in 1:nnodes_projection
             w_ij = get_node_vars(w_M, eq_relax, dg, i, j)
             u_cons = entropy2cons(w_ij, eq_relax)
-            f_cons = flux(u_cons,1,eq_relax)
-            set_node_vars!(f_M,f_cons,eq_relax,dg,i,j)
-            g_cons = flux(u_cons,2,eq_relax)
-            set_node_vars!(g_M,g_cons,eq_relax,dg,i,j)
+            f_cons = flux(u_cons, 1, eq_relax)
+            set_node_vars!(f_M, f_cons, eq_relax, dg, i, j)
+            g_cons = flux(u_cons, 2, eq_relax)
+            set_node_vars!(g_M, g_cons, eq_relax, dg, i, j)
         end
         # compute projection of f with M values down to N, same for g
-        multiply_dimensionwise!(f_N,project_M_to_N,f_M,tmp_NxM)
-        multiply_dimensionwise!(g_N,project_M_to_N,g_M,tmp_NxM)
+        multiply_dimensionwise!(f_N, project_M_to_N, f_M, tmp_NxM)
+        multiply_dimensionwise!(g_N, project_M_to_N, g_M, tmp_NxM)
         #@assert nnodes_projection == nnodes(dg) 
         #for j in 1:nnodes_projection, i in 1:nnodes_projection
         #    u_cons = get_node_vars(u_N, eq_relax, dg, i, j)
@@ -124,8 +124,8 @@ function perform_idp_correction!(u, dt, mesh::TreeMesh2D, equations::JinXinEquat
         for j in eachnode(dg), i in eachnode(dg)
             u_node = get_node_vars(u, equations, dg, i, j, element)
             # compute compressible Euler fluxes
-            vu = get_node_vars(f_N,eq_relax,dg,i,j)
-            wu = get_node_vars(g_N,eq_relax,dg,i,j)
+            vu = get_node_vars(f_N, eq_relax, dg, i, j)
+            wu = get_node_vars(g_N, eq_relax, dg, i, j)
             # compute relaxation terms
             du1 = u_node[1]
             du2 = u_node[2]
@@ -136,10 +136,11 @@ function perform_idp_correction!(u, dt, mesh::TreeMesh2D, equations::JinXinEquat
             du7 = factor * (eps * u_node[7] + dt_ * vu[3])
             du8 = factor * (eps * u_node[8] + dt_ * vu[4])
             du9 = factor * (eps * u_node[9] + dt_ * wu[1])
-            du10= factor * (eps * u_node[10]+ dt_ * wu[2])
-            du11= factor * (eps * u_node[11]+ dt_ * wu[3])
-            du12= factor * (eps * u_node[12]+ dt_ * wu[4])
-            new_u = SVector(du1, du2, du3, du4, du5, du6, du7, du8, du9, du10, du11, du12)
+            du10 = factor * (eps * u_node[10] + dt_ * wu[2])
+            du11 = factor * (eps * u_node[11] + dt_ * wu[3])
+            du12 = factor * (eps * u_node[12] + dt_ * wu[4])
+            new_u = SVector(du1, du2, du3, du4, du5, du6, du7, du8, du9, du10, du11,
+                            du12)
             set_node_vars!(u, new_u, equations, dg, i, j, element)
         end
     end
diff --git a/src/callbacks_step/alive.jl b/src/callbacks_step/alive.jl
index 9df7181521..0d26d9bd01 100644
--- a/src/callbacks_step/alive.jl
+++ b/src/callbacks_step/alive.jl
@@ -45,7 +45,7 @@ function Base.show(io::IO, ::MIME"text/plain",
         alive_callback = cb.affect!
 
         setup = [
-            "interval" => alive_callback.alive_interval,
+            "interval" => alive_callback.alive_interval
         ]
         summary_box(io, "AliveCallback", setup)
     end
diff --git a/src/callbacks_step/analysis_dg2d.jl b/src/callbacks_step/analysis_dg2d.jl
index 53f586938b..41136f91e7 100644
--- a/src/callbacks_step/analysis_dg2d.jl
+++ b/src/callbacks_step/analysis_dg2d.jl
@@ -245,7 +245,7 @@ function analyze(::typeof(entropy_timederivative), du, u, t,
 
     # Calculate ∫(∂S/∂u ⋅ ∂u/∂t)dΩ
     result = integrate_via_indices(u, mesh, equations, dg, cache,
-                          du) do u, i, j, element, equations, dg, du
+                                   du) do u, i, j, element, equations, dg, du
         u_node = get_node_vars(u, equations, dg, i, j, element)
         du_node = get_node_vars(du, equations, dg, i, j, element)
         dot(cons2entropy(u_node, equations), du_node)
diff --git a/src/callbacks_step/averaging.jl b/src/callbacks_step/averaging.jl
index efa71af9b9..d23abe2869 100644
--- a/src/callbacks_step/averaging.jl
+++ b/src/callbacks_step/averaging.jl
@@ -45,7 +45,7 @@ function Base.show(io::IO, ::MIME"text/plain",
 
         setup = [
             "Start time" => first(averaging_callback.tspan),
-            "Final time" => last(averaging_callback.tspan),
+            "Final time" => last(averaging_callback.tspan)
         ]
         summary_box(io, "AveragingCallback", setup)
     end
diff --git a/src/callbacks_step/glm_speed.jl b/src/callbacks_step/glm_speed.jl
index 8ee406af5f..5736af91d4 100644
--- a/src/callbacks_step/glm_speed.jl
+++ b/src/callbacks_step/glm_speed.jl
@@ -48,7 +48,7 @@ function Base.show(io::IO, ::MIME"text/plain",
         setup = [
             "GLM wave speed scaling" => glm_speed_callback.glm_scale,
             "Expected CFL number" => glm_speed_callback.cfl,
-            "Selected semidiscretizations" => glm_speed_callback.semi_indices,
+            "Selected semidiscretizations" => glm_speed_callback.semi_indices
         ]
         summary_box(io, "GlmSpeedCallback", setup)
     end
diff --git a/src/callbacks_step/save_restart.jl b/src/callbacks_step/save_restart.jl
index 0d174d8580..98a681d1b3 100644
--- a/src/callbacks_step/save_restart.jl
+++ b/src/callbacks_step/save_restart.jl
@@ -38,7 +38,7 @@ function Base.show(io::IO, ::MIME"text/plain",
             "interval" => save_restart_callback.interval,
             "save final solution" => save_restart_callback.save_final_restart ? "yes" :
                                      "no",
-            "output directory" => abspath(normpath(save_restart_callback.output_directory)),
+            "output directory" => abspath(normpath(save_restart_callback.output_directory))
         ]
         summary_box(io, "SaveRestartCallback", setup)
     end
diff --git a/src/callbacks_step/save_solution.jl b/src/callbacks_step/save_solution.jl
index c106fe69bc..c6ac303c1c 100644
--- a/src/callbacks_step/save_solution.jl
+++ b/src/callbacks_step/save_solution.jl
@@ -62,7 +62,7 @@ function Base.show(io::IO, ::MIME"text/plain",
                                        "yes" : "no",
             "save final solution" => save_solution_callback.save_final_solution ?
                                      "yes" : "no",
-            "output directory" => abspath(normpath(save_solution_callback.output_directory)),
+            "output directory" => abspath(normpath(save_solution_callback.output_directory))
         ]
         summary_box(io, "SaveSolutionCallback", setup)
     end
@@ -85,7 +85,7 @@ function Base.show(io::IO, ::MIME"text/plain",
                                        "yes" : "no",
             "save final solution" => save_solution_callback.save_final_solution ?
                                      "yes" : "no",
-            "output directory" => abspath(normpath(save_solution_callback.output_directory)),
+            "output directory" => abspath(normpath(save_solution_callback.output_directory))
         ]
         summary_box(io, "SaveSolutionCallback", setup)
     end
diff --git a/src/callbacks_step/steady_state.jl b/src/callbacks_step/steady_state.jl
index 15c2e83428..7085d05394 100644
--- a/src/callbacks_step/steady_state.jl
+++ b/src/callbacks_step/steady_state.jl
@@ -43,7 +43,7 @@ function Base.show(io::IO, ::MIME"text/plain",
 
         setup = [
             "absolute tolerance" => steady_state_callback.abstol,
-            "relative tolerance" => steady_state_callback.reltol,
+            "relative tolerance" => steady_state_callback.reltol
         ]
         summary_box(io, "SteadyStateCallback", setup)
     end
diff --git a/src/callbacks_step/stepsize.jl b/src/callbacks_step/stepsize.jl
index 8b5cb95831..0a95cb35ad 100644
--- a/src/callbacks_step/stepsize.jl
+++ b/src/callbacks_step/stepsize.jl
@@ -33,7 +33,7 @@ function Base.show(io::IO, ::MIME"text/plain",
         stepsize_callback = cb.affect!
 
         setup = [
-            "CFL number" => stepsize_callback.cfl_number,
+            "CFL number" => stepsize_callback.cfl_number
         ]
         summary_box(io, "StepsizeCallback", setup)
     end
diff --git a/src/callbacks_step/time_series.jl b/src/callbacks_step/time_series.jl
index ae18c85700..d3c9861d33 100644
--- a/src/callbacks_step/time_series.jl
+++ b/src/callbacks_step/time_series.jl
@@ -72,7 +72,7 @@ function Base.show(io::IO, ::MIME"text/plain",
             "interval" => time_series_callback.interval,
             "solution_variables" => time_series_callback.solution_variables,
             "output_directory" => time_series_callback.output_directory,
-            "filename" => time_series_callback.filename,
+            "filename" => time_series_callback.filename
         ]
         summary_box(io, "TimeSeriesCallback", setup)
     end
diff --git a/src/callbacks_step/visualization.jl b/src/callbacks_step/visualization.jl
index 98c0126a30..513bde4e0c 100644
--- a/src/callbacks_step/visualization.jl
+++ b/src/callbacks_step/visualization.jl
@@ -50,7 +50,7 @@ function Base.show(io::IO, ::MIME"text/plain",
             "variable names" => visualization_callback.variable_names,
             "show mesh" => visualization_callback.show_mesh,
             "plot creator" => visualization_callback.plot_creator,
-            "plot data creator" => visualization_callback.plot_data_creator,
+            "plot data creator" => visualization_callback.plot_data_creator
         ]
         summary_box(io, "VisualizationCallback", setup)
     end
diff --git a/src/equations/equations.jl b/src/equations/equations.jl
index 5f69528be1..6ffa378fc5 100644
--- a/src/equations/equations.jl
+++ b/src/equations/equations.jl
@@ -517,5 +517,4 @@ include("traffic_flow_lwr_1d.jl")
 abstract type AbstractJinXinEquations{NDIMS, NVARS} <:
               AbstractEquations{NDIMS, NVARS} end
 include("jin_xin_compressible_euler_2d.jl")
-
 end # @muladd
diff --git a/src/equations/jin_xin_compressible_euler_2d.jl b/src/equations/jin_xin_compressible_euler_2d.jl
index 660c08d4ae..ed6379ef74 100644
--- a/src/equations/jin_xin_compressible_euler_2d.jl
+++ b/src/equations/jin_xin_compressible_euler_2d.jl
@@ -10,14 +10,16 @@
 
 TODO: Write a proper docstring
 """
-struct JinXinEquations{NDIMS, NVARS, NVARS_BASE, EquationsBase <: AbstractEquations{NDIMS, NVARS_BASE}, RealT <: Real} <:
+struct JinXinEquations{NDIMS, NVARS, NVARS_BASE,
+                       EquationsBase <: AbstractEquations{NDIMS, NVARS_BASE},
+                       RealT <: Real} <:
        AbstractJinXinEquations{NDIMS, NVARS}
     equations_base::EquationsBase
     # relaxation parameter of the Jin Xin relaxation model
     # The relaxed equations should converge to the original equations
     # as the relaxation parameter epsilon -> 0
-    eps_relaxation    ::RealT
-    eps_relaxation_inv::RealT
+    eps_relaxation     :: RealT
+    eps_relaxation_inv :: RealT
 
     # velocity parameters of the Jin Xin relaxation model
     # They need to satisfy the subcharacteristic condition, i.e., they
@@ -29,7 +31,6 @@ struct JinXinEquations{NDIMS, NVARS, NVARS_BASE, EquationsBase <: AbstractEquati
 end
 
 function JinXinEquations(equations_base, eps_relaxation, velocities)
-
     sqrt_velocities = map(velocities) do v
         sqrt_v = sqrt.(v)
         return sqrt_v
@@ -42,8 +43,9 @@ function JinXinEquations(equations_base, eps_relaxation, velocities)
     NDIMS = ndims(equations_base)
     NVARS_BASE = nvariables(equations_base)
     RealT = promote_type(typeof(eps_relaxation), eltype(eltype(velocities)))
-    JinXinEquations{NDIMS, (NDIMS + 1) * NVARS_BASE, NVARS_BASE, typeof(equations_base), RealT}(equations_base, eps_relaxation, inv(eps_relaxation),
-                    velocities, sqrt_velocities, sqrt_velocities_inv)
+    JinXinEquations{NDIMS, (NDIMS + 1) * NVARS_BASE, NVARS_BASE, typeof(equations_base),
+                    RealT}(equations_base, eps_relaxation, inv(eps_relaxation),
+                           velocities, sqrt_velocities, sqrt_velocities_inv)
 end
 
 function varnames(func::typeof(cons2cons), equations::JinXinEquations)
@@ -79,7 +81,7 @@ end
 
 # Set initial conditions at physical location `x` for time `t`
 struct InitialConditionJinXin{IC}
-  initial_condition::IC
+    initial_condition::IC
 end
 
 @inline function (ic::InitialConditionJinXin)(x, t, equations::JinXinEquations)
@@ -131,13 +133,11 @@ end
 #     return SVector(du1, du2, du3, du4, du5, du6, du7, du8, du9, du10, du11, du12)
 # end
 
-
 function get_block_components(u, n, equations::JinXinEquations)
     nvars_base = nvariables(equations.equations_base)
     return SVector(ntuple(i -> u[i + (n - 1) * nvars_base], Val(nvars_base)))
 end
 
-
 # Calculate 1D flux in for a single point
 # TODO: Implement 1D and 3D
 @inline function flux(u, orientation::Integer, equations::JinXinEquations{2})
@@ -154,15 +154,13 @@ end
     end
 end
 
-
 @inline function flux(u, orientation::Integer, equations::JinXinEquations{1})
-        u_base = get_block_components(u, 1, equations)
-        fluxes = get_block_components(u, 2, equations)
-        velocities = equations.velocities[1]
-        return SVector(fluxes..., (velocities .* u_base)...)
+    u_base = get_block_components(u, 1, equations)
+    fluxes = get_block_components(u, 2, equations)
+    velocities = equations.velocities[1]
+    return SVector(fluxes..., (velocities .* u_base)...)
 end
 
-
 # TODO: Implement 1D and 3D
 @inline function flux_upwind(u_ll, u_rr, orientation::Integer,
                              equations::JinXinEquations{2})
@@ -188,26 +186,24 @@ end
     end
 
     return 0.5f0 * (flux(u_ll, orientation, equations) +
-                    flux(u_rr, orientation, equations) - dissipation)
+            flux(u_rr, orientation, equations) - dissipation)
 end
 
-
 @inline function flux_upwind(u_ll, u_rr, orientation::Integer,
                              equations::JinXinEquations{1})
     u_ll_base = get_block_components(u_ll, 1, equations)
     u_rr_base = get_block_components(u_rr, 1, equations)
 
-        sqrt_velocities = equations.sqrt_velocities[1]
-        f_ll_base = get_block_components(u_ll, 2, equations)
-        f_rr_base = get_block_components(u_rr, 2, equations)
-        dissipation = SVector((sqrt_velocities .* (u_rr_base - u_ll_base))...,
-                              #   (sqrt_velocities .* (f_rr_base + f_ll_base))..., @ranocha: is this correct?
-                              (sqrt_velocities .* (f_rr_base - f_ll_base))...)
+    sqrt_velocities = equations.sqrt_velocities[1]
+    f_ll_base = get_block_components(u_ll, 2, equations)
+    f_rr_base = get_block_components(u_rr, 2, equations)
+    dissipation = SVector((sqrt_velocities .* (u_rr_base - u_ll_base))...,
+                          #   (sqrt_velocities .* (f_rr_base + f_ll_base))..., @ranocha: is this correct?
+                          (sqrt_velocities .* (f_rr_base - f_ll_base))...)
     return 0.5f0 * (flux(u_ll, orientation, equations) +
-                    flux(u_rr, orientation, equations) - dissipation)
+            flux(u_rr, orientation, equations) - dissipation)
 end
 
-
 @inline function max_abs_speeds(u, equations::JinXinEquations{2})
     return ntuple(Val(ndims(equations))) do n
         # maximum(equations.sqrt_velocities_inv[n]) @ranocha: is this correct?
@@ -215,7 +211,6 @@ end
     end
 end
 
-
 @inline function max_abs_speeds(u, equations::JinXinEquations{1})
     return ntuple(Val(ndims(equations))) do n
         # maximum(equations.sqrt_velocities_inv[n]) @ranocha: is this correct?
diff --git a/src/meshes/p4est_mesh.jl b/src/meshes/p4est_mesh.jl
index 6bb9819623..49dfd2419d 100644
--- a/src/meshes/p4est_mesh.jl
+++ b/src/meshes/p4est_mesh.jl
@@ -106,7 +106,7 @@ function Base.show(io::IO, ::MIME"text/plain", mesh::P4estMesh)
         setup = [
             "#trees" => ntrees(mesh),
             "current #cells" => ncells(mesh),
-            "polydeg" => length(mesh.nodes) - 1,
+            "polydeg" => length(mesh.nodes) - 1
         ]
         summary_box(io,
                     "P4estMesh{" * string(ndims(mesh)) * ", " * string(real(mesh)) *
diff --git a/src/meshes/t8code_mesh.jl b/src/meshes/t8code_mesh.jl
index 0af4c6ae02..05642b8d72 100644
--- a/src/meshes/t8code_mesh.jl
+++ b/src/meshes/t8code_mesh.jl
@@ -92,7 +92,7 @@ function Base.show(io::IO, ::MIME"text/plain", mesh::T8codeMesh)
         setup = [
             "#trees" => ntrees(mesh),
             "current #cells" => ncells(mesh),
-            "polydeg" => length(mesh.nodes) - 1,
+            "polydeg" => length(mesh.nodes) - 1
         ]
         summary_box(io,
                     "T8codeMesh{" * string(ndims(mesh)) * ", " * string(real(mesh)) * "}",
@@ -976,7 +976,7 @@ function fill_mesh_info!(mesh::T8codeMesh, interfaces, mortars, boundaries,
         [1, 2, 0, 0, 3, 4, 0, 0], # 2
         [0, 0, 1, 2, 0, 0, 3, 4], # 3
         [1, 2, 3, 4, 0, 0, 0, 0], # 4
-        [0, 0, 0, 0, 1, 2, 3, 4], # 5
+        [0, 0, 0, 0, 1, 2, 3, 4] # 5
     ]
 
     # Helper variables to compute unique global MPI interface/mortar ids.
@@ -1229,10 +1229,10 @@ function fill_mesh_info!(mesh::T8codeMesh, interfaces, mortars, boundaries,
                                 global_mortar_id_to_local[global_mortar_id] = local_mpi_mortar_id
 
                                 mpi_mesh_info.mpi_mortars.local_neighbor_ids[local_mpi_mortar_id] = [
-                                    current_index + 1,
+                                    current_index + 1
                                 ]
                                 mpi_mesh_info.mpi_mortars.local_neighbor_positions[local_mpi_mortar_id] = [
-                                    map_iface_to_ichild_to_position[iface + 1][t8_element_child_id(eclass_scheme, element) + 1],
+                                    map_iface_to_ichild_to_position[iface + 1][t8_element_child_id(eclass_scheme, element) + 1]
                                 ]
                                 init_mortar_node_indices!(mpi_mesh_info.mpi_mortars,
                                                           (iface, dual_faces[1]),
@@ -1240,7 +1240,7 @@ function fill_mesh_info!(mesh::T8codeMesh, interfaces, mortars, boundaries,
 
                                 neighbor_ranks = [
                                     remotes[findlast(ghost_remote_first_elem .<=
-                                                     neighbor_ielements[1])],
+                                                     neighbor_ielements[1])]
                                 ]
                                 mpi_mesh_info.neighbor_ranks_mortar[local_mpi_mortar_id] = neighbor_ranks
 
diff --git a/src/meshes/tree_mesh.jl b/src/meshes/tree_mesh.jl
index 1092fc54cc..933bfa6272 100644
--- a/src/meshes/tree_mesh.jl
+++ b/src/meshes/tree_mesh.jl
@@ -200,7 +200,7 @@ function Base.show(io::IO, ::MIME"text/plain",
             "periodicity" => mesh.tree.periodicity,
             "current #cells" => mesh.tree.length,
             "#leaf-cells" => count_leaf_cells(mesh.tree),
-            "maximum #cells" => mesh.tree.capacity,
+            "maximum #cells" => mesh.tree.capacity
         ]
         summary_box(io, "TreeMesh{" * string(NDIMS) * ", " * string(TreeType) * "}",
                     setup)
diff --git a/src/semidiscretization/semidiscretization_euler_gravity.jl b/src/semidiscretization/semidiscretization_euler_gravity.jl
index 4201344df8..97524fb505 100644
--- a/src/semidiscretization/semidiscretization_euler_gravity.jl
+++ b/src/semidiscretization/semidiscretization_euler_gravity.jl
@@ -59,7 +59,7 @@ function Base.show(io::IO, ::MIME"text/plain", parameters::ParametersEulerGravit
             "gravitational constant (G)" => parameters.gravitational_constant,
             "CFL (gravity)" => parameters.cfl,
             "max. #iterations" => parameters.n_iterations_max,
-            "time integrator" => parameters.timestep_gravity,
+            "time integrator" => parameters.timestep_gravity
         ]
         summary_box(io, "ParametersEulerGravity", setup)
     end
diff --git a/src/solvers/dg.jl b/src/solvers/dg.jl
index 768ae5f697..6467981557 100644
--- a/src/solvers/dg.jl
+++ b/src/solvers/dg.jl
@@ -95,7 +95,7 @@ function Base.show(io::IO, ::MIME"text/plain", integral::VolumeIntegralFluxDiffe
         show(io, integral)
     else
         setup = [
-            "volume flux" => integral.volume_flux,
+            "volume flux" => integral.volume_flux
         ]
         summary_box(io, "VolumeIntegralFluxDifferencing", setup)
     end
@@ -187,7 +187,7 @@ function Base.show(io::IO, ::MIME"text/plain",
         show(io, integral)
     else
         setup = [
-            "FV flux" => integral.volume_flux_fv,
+            "FV flux" => integral.volume_flux_fv
         ]
         summary_box(io, "VolumeIntegralPureLGLFiniteVolume", setup)
     end
@@ -284,7 +284,7 @@ function Base.show(io::IO, ::MIME"text/plain", integral::VolumeIntegralUpwind)
         show(io, integral)
     else
         setup = [
-            "flux splitting" => integral.splitting,
+            "flux splitting" => integral.splitting
         ]
         summary_box(io, "VolumeIntegralUpwind", setup)
     end
@@ -324,7 +324,7 @@ function Base.show(io::IO, ::MIME"text/plain", integral::SurfaceIntegralWeakForm
         show(io, integral)
     else
         setup = [
-            "surface flux" => integral.surface_flux,
+            "surface flux" => integral.surface_flux
         ]
         summary_box(io, "SurfaceIntegralWeakForm", setup)
     end
@@ -350,7 +350,7 @@ function Base.show(io::IO, ::MIME"text/plain", integral::SurfaceIntegralStrongFo
         show(io, integral)
     else
         setup = [
-            "surface flux" => integral.surface_flux,
+            "surface flux" => integral.surface_flux
         ]
         summary_box(io, "SurfaceIntegralStrongForm", setup)
     end
@@ -381,7 +381,7 @@ function Base.show(io::IO, ::MIME"text/plain", integral::SurfaceIntegralUpwind)
         show(io, integral)
     else
         setup = [
-            "flux splitting" => integral.splitting,
+            "flux splitting" => integral.splitting
         ]
         summary_box(io, "SurfaceIntegralUpwind", setup)
     end
diff --git a/src/solvers/dgsem/basis_gauss_legendre.jl b/src/solvers/dgsem/basis_gauss_legendre.jl
index b9aafeb9da..1548ea8e7f 100644
--- a/src/solvers/dgsem/basis_gauss_legendre.jl
+++ b/src/solvers/dgsem/basis_gauss_legendre.jl
@@ -38,7 +38,9 @@ struct GaussLegendreBasis{RealT <: Real, NNODES,
     filter_modal_to_cutoff::DerivativeMatrix # compute modal cutoff filter via Legendre modes, cut off modes at polydeg_cutoff
 end
 
-function GaussLegendreBasis(RealT, polydeg::Integer; polydeg_projection::Integer = 2 * polydeg, polydeg_cutoff::Integer = div(polydeg + 1, 2) - 1)
+function GaussLegendreBasis(RealT, polydeg::Integer;
+                            polydeg_projection::Integer = 2 * polydeg,
+                            polydeg_cutoff::Integer = div(polydeg + 1, 2) - 1)
     nnodes_ = polydeg + 1
 
     # compute everything using `Float64` by default
@@ -74,39 +76,43 @@ function GaussLegendreBasis(RealT, polydeg::Integer; polydeg_projection::Integer
     # L2 projection operators
     nnodes_projection = polydeg_projection + 1
     nodes_projection, weights_projection = gauss_nodes_weights(nnodes_projection)
-    interpolate_N_to_M_ = polynomial_interpolation_matrix(nodes_, nodes_projection) 
+    interpolate_N_to_M_ = polynomial_interpolation_matrix(nodes_, nodes_projection)
     interpolate_N_to_M = Matrix{RealT}(interpolate_N_to_M_)
 
-    project_M_to_N_,filter_modal_to_N_ = calc_projection_matrix(nodes_projection, nodes_)
-    project_M_to_N  = Matrix{RealT}(project_M_to_N_)
-    filter_modal_to_N  = Matrix{RealT}(filter_modal_to_N_)
+    project_M_to_N_, filter_modal_to_N_ = calc_projection_matrix(nodes_projection,
+                                                                 nodes_)
+    project_M_to_N = Matrix{RealT}(project_M_to_N_)
+    filter_modal_to_N = Matrix{RealT}(filter_modal_to_N_)
 
     nnodes_cutoff = polydeg_cutoff + 1
     nodes_cutoff, weights_cutoff = gauss_nodes_weights(nnodes_cutoff)
     _, filter_modal_to_cutoff_ = calc_projection_matrix(nodes_, nodes_cutoff)
-    filter_modal_to_cutoff  = Matrix{RealT}(filter_modal_to_cutoff_)
+    filter_modal_to_cutoff = Matrix{RealT}(filter_modal_to_cutoff_)
 
     return GaussLegendreBasis{RealT, nnodes_, typeof(nodes),
-                                typeof(inverse_vandermonde_legendre),
-                                typeof(boundary_interpolation),
-                                typeof(derivative_matrix),
-                                typeof(interpolate_N_to_M),
-                                typeof(project_M_to_N),
-                                typeof(filter_modal_to_N)}(nodes, weights,
-                                                        inverse_weights,
-                                                        inverse_vandermonde_legendre,
-                                                        boundary_interpolation,
-                                                        derivative_matrix,
-                                                        derivative_split,
-                                                        derivative_split_transpose,
-                                                        derivative_dhat,
-                                                        interpolate_N_to_M,
-                                                        project_M_to_N,
-                                                        filter_modal_to_N,
-                                                        filter_modal_to_cutoff)
+                              typeof(inverse_vandermonde_legendre),
+                              typeof(boundary_interpolation),
+                              typeof(derivative_matrix),
+                              typeof(interpolate_N_to_M),
+                              typeof(project_M_to_N),
+                              typeof(filter_modal_to_N)}(nodes, weights,
+                                                         inverse_weights,
+                                                         inverse_vandermonde_legendre,
+                                                         boundary_interpolation,
+                                                         derivative_matrix,
+                                                         derivative_split,
+                                                         derivative_split_transpose,
+                                                         derivative_dhat,
+                                                         interpolate_N_to_M,
+                                                         project_M_to_N,
+                                                         filter_modal_to_N,
+                                                         filter_modal_to_cutoff)
 end
 
-GaussLegendreBasis(polydeg::Integer; polydeg_projection::Integer = 2 * polydeg, polydeg_cutoff::Integer = div(polydeg + 1, 2) - 1) = GaussLegendreBasis(Float64, polydeg; polydeg_projection, polydeg_cutoff)
+GaussLegendreBasis(polydeg::Integer; polydeg_projection::Integer = 2 * polydeg, polydeg_cutoff::Integer = div(polydeg + 1, 2) - 1) = GaussLegendreBasis(Float64,
+                                                                                                                                                        polydeg;
+                                                                                                                                                        polydeg_projection,
+                                                                                                                                                        polydeg_cutoff)
 
 function Base.show(io::IO, basis::GaussLegendreBasis)
     @nospecialize basis # reduce precompilation time
@@ -137,7 +143,7 @@ end
 @inline Base.real(basis::GaussLegendreBasis{RealT}) where {RealT} = RealT
 
 @inline function nnodes(basis::GaussLegendreBasis{RealT, NNODES}) where {RealT, NNODES
-                                                                           }
+                                                                         }
     NNODES
 end
 
@@ -178,8 +184,8 @@ left_boundary_weight(basis::GaussLegendreBasis) = first(basis.weights)
 right_boundary_weight(basis::GaussLegendreBasis) = last(basis.weights)
 
 struct GaussLegendreAnalyzer{RealT <: Real, NNODES,
-                               VectorT <: AbstractVector{RealT},
-                               Vandermonde <: AbstractMatrix{RealT}} <:
+                             VectorT <: AbstractVector{RealT},
+                             Vandermonde <: AbstractMatrix{RealT}} <:
        SolutionAnalyzer{RealT}
     nodes::VectorT
     weights::VectorT
@@ -223,7 +229,7 @@ end
 @inline Base.real(analyzer::GaussLegendreAnalyzer{RealT}) where {RealT} = RealT
 
 @inline function nnodes(analyzer::GaussLegendreAnalyzer{RealT, NNODES}) where {RealT,
-                                                                                 NNODES}
+                                                                               NNODES}
     NNODES
 end
 """
@@ -236,5 +242,4 @@ In particular, not the nodes themselves are returned.
 @inline eachnode(analyzer::GaussLegendreAnalyzer) = Base.OneTo(nnodes(analyzer))
 
 @inline polydeg(analyzer::GaussLegendreAnalyzer) = nnodes(analyzer) - 1
-
 end # @muladd
diff --git a/src/solvers/dgsem/basis_lobatto_legendre.jl b/src/solvers/dgsem/basis_lobatto_legendre.jl
index 1bd3d9efa1..ce04a8eaf5 100644
--- a/src/solvers/dgsem/basis_lobatto_legendre.jl
+++ b/src/solvers/dgsem/basis_lobatto_legendre.jl
@@ -42,7 +42,9 @@ struct LobattoLegendreBasis{RealT <: Real, NNODES,
     filter_modal_to_cutoff::DerivativeMatrix # compute modal cutoff filter via Legendre modes, cut off modes at polydeg_cutoff
 end
 
-function LobattoLegendreBasis(RealT, polydeg::Integer; polydeg_projection::Integer = 2 * polydeg, polydeg_cutoff::Integer = div(polydeg + 1, 2) - 1)
+function LobattoLegendreBasis(RealT, polydeg::Integer;
+                              polydeg_projection::Integer = 2 * polydeg,
+                              polydeg_cutoff::Integer = div(polydeg + 1, 2) - 1)
     nnodes_ = polydeg + 1
 
     # compute everything using `Float64` by default
@@ -78,17 +80,18 @@ function LobattoLegendreBasis(RealT, polydeg::Integer; polydeg_projection::Integ
     # L2 projection operators
     nnodes_projection = polydeg_projection + 1
     nodes_projection, weights_projection = gauss_lobatto_nodes_weights(nnodes_projection)
-    interpolate_N_to_M_ = polynomial_interpolation_matrix(nodes_, nodes_projection) 
+    interpolate_N_to_M_ = polynomial_interpolation_matrix(nodes_, nodes_projection)
     interpolate_N_to_M = Matrix{RealT}(interpolate_N_to_M_)
 
-    project_M_to_N_,filter_modal_to_N_ = calc_projection_matrix(nodes_projection, nodes_)
-    project_M_to_N  = Matrix{RealT}(project_M_to_N_)
-    filter_modal_to_N  = Matrix{RealT}(filter_modal_to_N_)
+    project_M_to_N_, filter_modal_to_N_ = calc_projection_matrix(nodes_projection,
+                                                                 nodes_)
+    project_M_to_N = Matrix{RealT}(project_M_to_N_)
+    filter_modal_to_N = Matrix{RealT}(filter_modal_to_N_)
 
     nnodes_cutoff = polydeg_cutoff + 1
     nodes_cutoff, weights_cutoff = gauss_lobatto_nodes_weights(nnodes_cutoff)
     _, filter_modal_to_cutoff_ = calc_projection_matrix(nodes_, nodes_cutoff)
-    filter_modal_to_cutoff  = Matrix{RealT}(filter_modal_to_cutoff_)
+    filter_modal_to_cutoff = Matrix{RealT}(filter_modal_to_cutoff_)
 
     return LobattoLegendreBasis{RealT, nnodes_, typeof(nodes),
                                 typeof(inverse_vandermonde_legendre),
@@ -97,20 +100,23 @@ function LobattoLegendreBasis(RealT, polydeg::Integer; polydeg_projection::Integ
                                 typeof(interpolate_N_to_M),
                                 typeof(project_M_to_N),
                                 typeof(filter_modal_to_N)}(nodes, weights,
-                                                        inverse_weights,
-                                                        inverse_vandermonde_legendre,
-                                                        boundary_interpolation,
-                                                        derivative_matrix,
-                                                        derivative_split,
-                                                        derivative_split_transpose,
-                                                        derivative_dhat,
-                                                        interpolate_N_to_M,
-                                                        project_M_to_N,
-                                                        filter_modal_to_N,
-                                                        filter_modal_to_cutoff)
-end
-
-LobattoLegendreBasis(polydeg::Integer; polydeg_projection::Integer = 2 * polydeg, polydeg_cutoff::Integer = div(polydeg + 1, 2) - 1) = LobattoLegendreBasis(Float64, polydeg; polydeg_projection, polydeg_cutoff)
+                                                           inverse_weights,
+                                                           inverse_vandermonde_legendre,
+                                                           boundary_interpolation,
+                                                           derivative_matrix,
+                                                           derivative_split,
+                                                           derivative_split_transpose,
+                                                           derivative_dhat,
+                                                           interpolate_N_to_M,
+                                                           project_M_to_N,
+                                                           filter_modal_to_N,
+                                                           filter_modal_to_cutoff)
+end
+
+LobattoLegendreBasis(polydeg::Integer; polydeg_projection::Integer = 2 * polydeg, polydeg_cutoff::Integer = div(polydeg + 1, 2) - 1) = LobattoLegendreBasis(Float64,
+                                                                                                                                                            polydeg;
+                                                                                                                                                            polydeg_projection,
+                                                                                                                                                            polydeg_cutoff)
 
 function Base.show(io::IO, basis::LobattoLegendreBasis)
     @nospecialize basis # reduce precompilation time
@@ -811,21 +817,21 @@ function vandermonde_legendre(nodes, N)
 end
 vandermonde_legendre(nodes) = vandermonde_legendre(nodes, length(nodes) - 1)
 
-function calc_projection_matrix(nodes_in,nodes_out)
-  # nodes_in are size M>N
-  nnodes_in=length(nodes_in)
-  polydeg_in = nnodes_in - 1
-  # nodes_out are size N
-  nnodes_out = length(nodes_out)
-  vandermonde_in,inverse_vandermonde_in = vandermonde_legendre(nodes_in,polydeg_in)
-  filter_matrix = zeros(nnodes_in,nnodes_in)
-  for j in 1:nnodes_out
-    filter_matrix[j,j] = 1
-  end
-  interpolate_M_to_N = polynomial_interpolation_matrix(nodes_in, nodes_out)
-  filter_modal = vandermonde_in * filter_matrix * inverse_vandermonde_in
-  projection_matrix = interpolate_M_to_N * vandermonde_in * filter_matrix * inverse_vandermonde_in
-  return projection_matrix, filter_modal
+function calc_projection_matrix(nodes_in, nodes_out)
+    # nodes_in are size M>N
+    nnodes_in = length(nodes_in)
+    polydeg_in = nnodes_in - 1
+    # nodes_out are size N
+    nnodes_out = length(nodes_out)
+    vandermonde_in, inverse_vandermonde_in = vandermonde_legendre(nodes_in, polydeg_in)
+    filter_matrix = zeros(nnodes_in, nnodes_in)
+    for j in 1:nnodes_out
+        filter_matrix[j, j] = 1
+    end
+    interpolate_M_to_N = polynomial_interpolation_matrix(nodes_in, nodes_out)
+    filter_modal = vandermonde_in * filter_matrix * inverse_vandermonde_in
+    projection_matrix = interpolate_M_to_N * vandermonde_in * filter_matrix *
+                        inverse_vandermonde_in
+    return projection_matrix, filter_modal
 end
-
 end # @muladd
diff --git a/src/solvers/dgsem_tree/dg_2d.jl b/src/solvers/dgsem_tree/dg_2d.jl
index 9d2917b966..f910327f7f 100644
--- a/src/solvers/dgsem_tree/dg_2d.jl
+++ b/src/solvers/dgsem_tree/dg_2d.jl
@@ -202,7 +202,7 @@ end
 function calc_entropy_projection!(u_projected, u, mesh, equations, dg, cache)
     # prepare local storage for projection
     @unpack interpolate_N_to_M, project_M_to_N = dg.basis
-    nnodes_,nnodes_projection = size(project_M_to_N)
+    nnodes_, nnodes_projection = size(project_M_to_N)
     nVars = nvariables(equations)
     RealT = real(dg)
     u_N = zeros(RealT, nVars, nnodes_, nnodes_)
@@ -218,22 +218,22 @@ function calc_entropy_projection!(u_projected, u, mesh, equations, dg, cache)
         for j in eachnode(dg), i in eachnode(dg)
             u_node = get_node_vars(u, equations, dg, i, j, element)
             for v in eachvariable(equations)
-                u_N[v,i,j] = u_node[v]
+                u_N[v, i, j] = u_node[v]
             end
         end
         # bring elemtn u_N to grid (M+1)x(M+1)
-        multiply_dimensionwise!(u_M,interpolate_N_to_M,u_N,tmp_MxN)
-     
+        multiply_dimensionwise!(u_M, interpolate_N_to_M, u_N, tmp_MxN)
+
         # compute nodal values of entropy variables w on the M grid
         for j in 1:nnodes_projection, i in 1:nnodes_projection
             u_cons = get_node_vars(u_M, equations, dg, i, j)
-            w_ij   = cons2entropy(u_cons,equations)
-            set_node_vars!(w_M,w_ij,equations,dg,i,j)
+            w_ij = cons2entropy(u_cons, equations)
+            set_node_vars!(w_M, w_ij, equations, dg, i, j)
         end
 
         # compute projection of w with M values down to N
-        multiply_dimensionwise!(w_N, project_M_to_N ,w_M, tmp_NxM)
-     
+        multiply_dimensionwise!(w_N, project_M_to_N, w_M, tmp_NxM)
+
         # compute nodal values of conservative variables from the projected entropy variables
         for j in eachnode(dg), i in eachnode(dg)
             w_ij = get_node_vars(w_N, equations, dg, i, j)
@@ -243,7 +243,8 @@ function calc_entropy_projection!(u_projected, u, mesh, equations, dg, cache)
     end
 end
 
-function calc_filter!(u_filtered, u, cons2filter, filter2cons, mesh, equations, dg, cache)
+function calc_filter!(u_filtered, u, cons2filter, filter2cons, mesh, equations, dg,
+                      cache)
     # prepare local storage for projection
     @unpack filter_modal_to_cutoff = dg.basis
     nnodes_ = nnodes(dg)
@@ -258,15 +259,15 @@ function calc_filter!(u_filtered, u, cons2filter, filter2cons, mesh, equations,
         # convert u to entropy variables
         for j in eachnode(dg), i in eachnode(dg)
             u_cons = get_node_vars(u, equations, dg, i, j, element)
-            w_ij   = cons2filter(u_cons, equations)
+            w_ij = cons2filter(u_cons, equations)
             for v in eachvariable(equations)
-                w_N[v,i,j] = w_ij[v]
+                w_N[v, i, j] = w_ij[v]
             end
         end
 
         # filter entropy variables
         multiply_dimensionwise!(w_N_filtered, filter_modal_to_cutoff, w_N, tmp_NxN)
-     
+
         # compute nodal values of conservative variables from the projected entropy variables
         for j in eachnode(dg), i in eachnode(dg)
             w_ij = get_node_vars(w_N_filtered, equations, dg, i, j)
@@ -334,7 +335,7 @@ function calc_volume_integral!(du, u,
                                dg::DGSEM, cache)
     # prepare local storage for projection
     @unpack interpolate_N_to_M, project_M_to_N, filter_modal_to_N = dg.basis
-    nnodes_,nnodes_projection = size(project_M_to_N)
+    nnodes_, nnodes_projection = size(project_M_to_N)
     nVars = nvariables(equations)
     RealT = real(dg)
     u_N = zeros(RealT, nVars, nnodes_, nnodes_)
@@ -355,9 +356,9 @@ function calc_volume_integral!(du, u,
         # get element u_N
         for j in eachnode(dg), i in eachnode(dg)
             u_node = get_node_vars(u, equations, dg, i, j, element)
-            w_ij   = cons2entropy(u_node, equations)
+            w_ij = cons2entropy(u_node, equations)
             for v in eachvariable(equations)
-                w_N[v,i,j] = w_ij[v]
+                w_N[v, i, j] = w_ij[v]
             end
         end
         # bring elemtn u_N to grid (M+1)x(M+1)
@@ -367,16 +368,16 @@ function calc_volume_integral!(du, u,
         for j in 1:nnodes_projection, i in 1:nnodes_projection
             w_ij = get_node_vars(w_M, equations, dg, i, j)
             u_cons = entropy2cons(w_ij, equations)
-            f_cons = flux(u_cons,1,equations)
-            set_node_vars!(f_M,f_cons,equations,dg,i,j)
-            g_cons = flux(u_cons,2,equations)
-            set_node_vars!(g_M,g_cons,equations,dg,i,j)
+            f_cons = flux(u_cons, 1, equations)
+            set_node_vars!(f_M, f_cons, equations, dg, i, j)
+            g_cons = flux(u_cons, 2, equations)
+            set_node_vars!(g_M, g_cons, equations, dg, i, j)
         end
         # compute projection of f with M values down to N, same for g
-        multiply_dimensionwise!(f_N,project_M_to_N,f_M,tmp_NxM)
-        multiply_dimensionwise!(g_N,project_M_to_N,g_M,tmp_NxM)
+        multiply_dimensionwise!(f_N, project_M_to_N, f_M, tmp_NxM)
+        multiply_dimensionwise!(g_N, project_M_to_N, g_M, tmp_NxM)
 
-        weak_form_kernel_projection!(du, u,f_N, g_N, element, mesh,
+        weak_form_kernel_projection!(du, u, f_N, g_N, element, mesh,
                                      nonconservative_terms, equations,
                                      dg, cache)
     end
@@ -396,13 +397,13 @@ end
     for j in eachnode(dg), i in eachnode(dg)
         u_node = get_node_vars(u, equations, dg, i, j, element)
 
-        flux1 = get_node_vars(f_N, equations, dg, i,j)
+        flux1 = get_node_vars(f_N, equations, dg, i, j)
         for ii in eachnode(dg)
             multiply_add_to_node_vars!(du, derivative_dhat[ii, i], flux1,
                                        equations, dg, ii, j, element)
         end
 
-        flux2 = get_node_vars(g_N, equations, dg, i,j)
+        flux2 = get_node_vars(g_N, equations, dg, i, j)
         for jj in eachnode(dg)
             multiply_add_to_node_vars!(du, derivative_dhat[jj, j], flux2,
                                        equations, dg, i, jj, element)
@@ -721,7 +722,8 @@ end
 end
 
 function prolong2interfaces!(cache, u,
-                             mesh::TreeMesh{2}, equations, surface_integral, dg::DG{<:LobattoLegendreBasis})
+                             mesh::TreeMesh{2}, equations, surface_integral,
+                             dg::DG{<:LobattoLegendreBasis})
     @unpack interfaces = cache
     @unpack orientations, neighbor_ids = interfaces
     interfaces_u = interfaces.u
@@ -749,7 +751,8 @@ function prolong2interfaces!(cache, u,
 end
 
 function prolong2interfaces!(cache, u,
-                             mesh::TreeMesh{2}, equations, surface_integral, dg::DG{<:GaussLegendreBasis})
+                             mesh::TreeMesh{2}, equations, surface_integral,
+                             dg::DG{<:GaussLegendreBasis})
     @unpack interfaces = cache
     @unpack orientations, neighbor_ids = interfaces
     @unpack boundary_interpolation, weights = dg.basis
@@ -765,8 +768,12 @@ function prolong2interfaces!(cache, u,
                 interfaces_u[1, v, j, interface] = 0
                 interfaces_u[2, v, j, interface] = 0
                 for ii in eachnode(dg)
-                    interfaces_u[1, v, j, interface] += u[v, ii, j, left_element] * weights[ii] * boundary_interpolation[ii, 2]
-                    interfaces_u[2, v, j, interface] += u[v, ii, j, right_element] * weights[ii] * boundary_interpolation[ii, 1]
+                    interfaces_u[1, v, j, interface] += u[v, ii, j, left_element] *
+                                                        weights[ii] *
+                                                        boundary_interpolation[ii, 2]
+                    interfaces_u[2, v, j, interface] += u[v, ii, j, right_element] *
+                                                        weights[ii] *
+                                                        boundary_interpolation[ii, 1]
                 end
             end
         else # if orientations[interface] == 2
@@ -775,8 +782,12 @@ function prolong2interfaces!(cache, u,
                 interfaces_u[1, v, i, interface] = 0
                 interfaces_u[2, v, i, interface] = 0
                 for jj in eachnode(dg)
-                    interfaces_u[1, v, i, interface] += u[v, i, jj, left_element] * weights[jj] * boundary_interpolation[jj, 2]
-                    interfaces_u[2, v, i, interface] += u[v, i, jj, right_element] * weights[jj] * boundary_interpolation[jj, 1]
+                    interfaces_u[1, v, i, interface] += u[v, i, jj, left_element] *
+                                                        weights[jj] *
+                                                        boundary_interpolation[jj, 2]
+                    interfaces_u[2, v, i, interface] += u[v, i, jj, right_element] *
+                                                        weights[jj] *
+                                                        boundary_interpolation[jj, 1]
                 end
             end
         end
diff --git a/src/solvers/dgsem_tree/indicators.jl b/src/solvers/dgsem_tree/indicators.jl
index 9f25a6d2db..eccc85cf20 100644
--- a/src/solvers/dgsem_tree/indicators.jl
+++ b/src/solvers/dgsem_tree/indicators.jl
@@ -96,7 +96,7 @@ function Base.show(io::IO, ::MIME"text/plain", indicator::IndicatorHennemannGass
         "indicator variable" => indicator.variable,
         "max. α" => indicator.alpha_max,
         "min. α" => indicator.alpha_min,
-        "smooth α" => (indicator.alpha_smooth ? "yes" : "no"),
+        "smooth α" => (indicator.alpha_smooth ? "yes" : "no")
     ]
     summary_box(io, "IndicatorHennemannGassner", setup)
 end
@@ -193,7 +193,7 @@ function Base.show(io::IO, ::MIME"text/plain", indicator::IndicatorLöhner)
     else
         setup = [
             "indicator variable" => indicator.variable,
-            "f_wave" => indicator.f_wave,
+            "f_wave" => indicator.f_wave
         ]
         summary_box(io, "IndicatorLöhner", setup)
     end
@@ -251,7 +251,7 @@ function Base.show(io::IO, ::MIME"text/plain", indicator::IndicatorMax)
         show(io, indicator)
     else
         setup = [
-            "indicator variable" => indicator.variable,
+            "indicator variable" => indicator.variable
         ]
         summary_box(io, "IndicatorMax", setup)
     end
diff --git a/src/solvers/dgsem_tree/subcell_limiters.jl b/src/solvers/dgsem_tree/subcell_limiters.jl
index 17c9488316..f3fc392e32 100644
--- a/src/solvers/dgsem_tree/subcell_limiters.jl
+++ b/src/solvers/dgsem_tree/subcell_limiters.jl
@@ -195,7 +195,7 @@ function Base.show(io::IO, ::MIME"text/plain", limiter::SubcellLimiterIDP)
             if local_twosided
                 setup = [
                     setup...,
-                    "" => "Local two-sided limiting for conservative variables $(limiter.local_twosided_variables_cons)",
+                    "" => "Local two-sided limiting for conservative variables $(limiter.local_twosided_variables_cons)"
                 ]
             end
             if positivity
@@ -203,7 +203,7 @@ function Base.show(io::IO, ::MIME"text/plain", limiter::SubcellLimiterIDP)
                 setup = [setup..., "" => string]
                 setup = [
                     setup...,
-                    "" => "- with positivity correction factor = $(limiter.positivity_correction_factor)",
+                    "" => "- with positivity correction factor = $(limiter.positivity_correction_factor)"
                 ]
             end
             if local_onesided
@@ -213,7 +213,7 @@ function Base.show(io::IO, ::MIME"text/plain", limiter::SubcellLimiterIDP)
             end
             setup = [
                 setup...,
-                "Local bounds" => "FV solution",
+                "Local bounds" => "FV solution"
             ]
         end
         summary_box(io, "SubcellLimiterIDP", setup)
diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index 82d54962b1..d8234d0ce5 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -35,21 +35,21 @@ struct SimpleIMEX{StageCallbacks} <: SimpleAlgorithmIMEX
         # the machine accuracy will occur, which will add up over time and thus endanger the
         # conservation of the simulation.
         # See also https://github.com/trixi-framework/Trixi.jl/pull/1640.
-        A1 = zeros(3,3)
-        A2 = zeros(3,3)
-        A1[2,1] = 0.5
-        A1[3,1] = 0.5
-        A1[3,2] = 0.5
-
-        A2[1,1] = 1/4
-        A2[2,2] = 1/4
-        A2[3,1] = 1/3
-        A2[3,2] = 1/3
-        A2[3,3] = 1/3
-
-        b = SVector(1/3, 1/3, 1/3) 
-        c1 = SVector(0.0, 1/2, 1)
-        c2 = SVector(1/4, 1/4, 1)
+        A1 = zeros(3, 3)
+        A2 = zeros(3, 3)
+        A1[2, 1] = 0.5
+        A1[3, 1] = 0.5
+        A1[3, 2] = 0.5
+
+        A2[1, 1] = 1 / 4
+        A2[2, 2] = 1 / 4
+        A2[3, 1] = 1 / 3
+        A2[3, 2] = 1 / 3
+        A2[3, 3] = 1 / 3
+
+        b = SVector(1 / 3, 1 / 3, 1 / 3)
+        c1 = SVector(0.0, 1 / 2, 1)
+        c2 = SVector(1 / 4, 1 / 4, 1)
 
         # Butcher tableau
         #   c |       a
@@ -59,7 +59,7 @@ struct SimpleIMEX{StageCallbacks} <: SimpleAlgorithmIMEX
         # --------------------
         #   b | 1/6  1/6  2/3
 
-        new{typeof(stage_callbacks)}(A1, A2, b, c1,c2,
+        new{typeof(stage_callbacks)}(A1, A2, b, c1, c2,
                                      stage_callbacks)
     end
 end
@@ -73,7 +73,8 @@ mutable struct SimpleIntegratorIMEXOptions{Callback, TStops}
     tstops::TStops # tstops from https://diffeq.sciml.ai/v6.8/basics/common_solver_opts/#Output-Control-1; ignored
 end
 
-function SimpleIntegratorIMEXOptions(callback, tspan; maxiters = typemax(Int), kwargs...)
+function SimpleIntegratorIMEXOptions(callback, tspan; maxiters = typemax(Int),
+                                     kwargs...)
     tstops_internal = BinaryHeap{eltype(tspan)}(FasterForward())
     # We add last(tspan) to make sure that the time integration stops at the end time
     push!(tstops_internal, last(tspan))
@@ -81,9 +82,9 @@ function SimpleIntegratorIMEXOptions(callback, tspan; maxiters = typemax(Int), k
     # (https://github.com/SciML/DiffEqCallbacks.jl/blob/025dfe99029bd0f30a2e027582744528eb92cd24/src/iterative_and_periodic.jl#L92)
     push!(tstops_internal, 2 * last(tspan))
     SimpleIntegratorIMEXOptions{typeof(callback), typeof(tstops_internal)}(callback,
-                                                                          false, Inf,
-                                                                          maxiters,
-                                                                          tstops_internal)
+                                                                           false, Inf,
+                                                                           maxiters,
+                                                                           tstops_internal)
 end
 
 # This struct is needed to fake https://github.com/SciML/OrdinaryDiffEq.jl/blob/0c2048a502101647ac35faabd80da8a5645beac7/src/integrators/type.jl#L77
@@ -91,7 +92,7 @@ end
 # https://diffeq.sciml.ai/v6.8/basics/integrator/#Handing-Integrators-1
 # which are used in Trixi.
 mutable struct SimpleIntegratorIMEX{RealT <: Real, uType, Params, Sol, F, Alg,
-                                   SimpleIntegratorIMEXOptions}
+                                    SimpleIntegratorIMEXOptions}
     u::uType
     u1::uType
     u2::uType
@@ -179,11 +180,13 @@ function solve(ode::ODEProblem, alg::SimpleAlgorithmIMEX;
     t = first(ode.tspan)
     tdir = sign(ode.tspan[end] - ode.tspan[1])
     iter = 0
-    integrator = SimpleIntegratorIMEX(u,u1,u2,u3,fu1,fu2,fu3,du1,du2,du3,du,u_tmp1,u_tmp2,u_tmp3, r0, t, tdir, dt, dt, iter, ode.p,
-                                     (prob = ode,), ode.f, alg,
-                                     SimpleIntegratorIMEXOptions(callback, ode.tspan;
-                                                                kwargs...),
-                                     false, true, false)
+    integrator = SimpleIntegratorIMEX(u, u1, u2, u3, fu1, fu2, fu3, du1, du2, du3, du,
+                                      u_tmp1, u_tmp2, u_tmp3, r0, t, tdir, dt, dt, iter,
+                                      ode.p,
+                                      (prob = ode,), ode.f, alg,
+                                      SimpleIntegratorIMEXOptions(callback, ode.tspan;
+                                                                  kwargs...),
+                                      false, true, false)
 
     # resize container
     resize!(integrator.p, nelements(integrator.p.solver, integrator.p.cache))
@@ -217,105 +220,133 @@ function solve!(integrator::SimpleIntegratorIMEX)
     relaxation_rate = equations.eps_relaxation
     integrator.finalstep = false
     @trixi_timeit timer() "main loop" while !integrator.finalstep
-            if isnan(integrator.dt)
-                error("time step size `dt` is NaN")
-            end
+        if isnan(integrator.dt)
+            error("time step size `dt` is NaN")
+        end
 
-            modify_dt_for_tstops!(integrator)
-            # if the next iteration would push the simulation beyond the end time, set dt accordingly
-                if integrator.t + integrator.dt > t_end ||
-                    isapprox(integrator.t + integrator.dt, t_end)
-                    integrator.dt = t_end - integrator.t
-                    terminate!(integrator)
-                end
-            integrator.u1 .= 0
-            integrator.u2 .= 0
-            integrator.u3 .= 0
-            integrator.du1 .= 0
-            integrator.du2 .= 0
-            integrator.du3 .= 0
-            integrator.fu1 .= 0
-            integrator.fu2 .= 0
-            integrator.fu3 .= 0
-            integrator.u_tmp1 .= 0
-            integrator.u_tmp2 .= 0
-            integrator.u_tmp3 .= 0
-                
-                #Ui = Un - dt sum A1_ij partial rhs(Uj) - dt/epsilon sum A2_ij (Vj - f(Uj))
-                #Un+1 = Un - dt sum bj partial rhs(Uj) - dt/epsilon sum bj (Vj - f(Uj))
-                
-                t_stage = integrator.t + integrator.dt * alg.c1[1]
-                
-                #   Stage 1
-                #Ui = (ui;vi)
-                #u1 = un
-                #v1 = vn - -dt/epsilon A2_{11} (v1 - f(u1)) 
-              @. integrator.u1 = integrator.u  #u1 = v1 = un
-              @. integrator.fu1 = integrator.u1
-                 wrap_and_perform_projection!(integrator.fu1,integrator.dt,mesh,equations,solver,cache)  # compute f(u1)
-              @. integrator.u1 = integrator.u1 + integrator.dt/relaxation_rate*alg.A2[1,1]*integrator.fu1 # v1 = vn + dt/eps*A2_11 f(u1)
-                
-                divide_relaxed_var!(integrator.u1,integrator.dt,semi,solver,cache,alg.A2[1,1],equations,mesh)  # v1 = (vn + dt/eps*A2_11 f(u1))/(1 + dt/eps A2_11)
-               
-                integrator.f(integrator.du1, integrator.u1, integrator.p, t_stage) # compute RHS(u1,v1)
-
-                # Stage 2        
-                #u2 = un - dt A1_{21} rhs(u1,v1) 
-                #v2 = vn - dt A1_{21} rhs(u1,v1) - dt/epsilon A2_{21} (v1 - f(u1)) -dt/epsilon A2_{22} (v2 - f(u2)) 
-                
-                t_stage = integrator.t + integrator.dt * alg.c1[2]
-           
-                @. integrator.u2 = integrator.u + integrator.dt*alg.A1[2,1]*integrator.du1 # u2 = v2 = Un - dt*A1_22 RHS(U1)
-
-                @. integrator.fu2 = integrator.u2
-                wrap_and_perform_projection!(integrator.fu2,integrator.dt,mesh,equations,solver,cache) # compute f(u2) and setting the source term values to 0 for the cons variables
-                
-                @. integrator.u_tmp1 = integrator.u1
-                set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache,equations,mesh) # computing v1 by setting cons variables to 0
-
-                # v2 = vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2)
-                @. integrator.u2 = integrator.u2 - integrator.dt/relaxation_rate*alg.A2[2,1]*(integrator.u_tmp1 - integrator.fu1) + integrator.dt*alg.A2[2,2]/relaxation_rate*integrator.fu2
-               
-                divide_relaxed_var!(integrator.u2,integrator.dt,semi,solver,cache,alg.A2[2,2],equations,mesh) # v2 = (vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2) ) ( 1+dt/eps A2_22)
-
-                integrator.f(integrator.du2, integrator.u2, integrator.p, t_stage)
-               
-                # Stage 3
-                #u3 = un - dt A1_{31} rhs(u1,v1) - dt A1_{32} rhs(u2,v2)
-                #v3 = vn - dt A1_{31} rhs(u1,v1) - dt A1_{32} rhs(u2,v2) - dt/epsilon A2_{31} (v1 - f(u1)) -dt/epsilon A2_{32} (v2 - f(u2)) -dt/epsilon A2_{33} (v3 - f(u3))
-                @. integrator.u3 = integrator.u + integrator.dt*alg.A1[3,1]*integrator.du1 + integrator.dt*alg.A1[3,2]*integrator.du2
-
-                @. integrator.fu3 = integrator.u3
-                wrap_and_perform_projection!(integrator.fu3,integrator.dt,mesh,equations,solver,cache)
-
-                #  @. integrator.u_tmp1 = integrator.u1
-                #  set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
-
-                @. integrator.u_tmp2 = integrator.u2
-                set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache,equations,mesh)
-
-                @. integrator.u3 = integrator.u3 - integrator.dt/relaxation_rate*alg.A2[3,1]*(integrator.u_tmp1 - integrator.fu1) - integrator.dt/relaxation_rate*alg.A2[3,2]*(integrator.u_tmp2 - integrator.fu2) + integrator.dt*alg.A2[3,3]/relaxation_rate*integrator.fu3
-                
-                divide_relaxed_var!(integrator.u3,integrator.dt,semi,solver,cache,alg.A2[3,3],equations,mesh) 
-                
-                integrator.f(integrator.du3, integrator.u3, integrator.p, t_stage)
-                
-                # Final Stage
-                @. integrator.u = integrator.u + integrator.dt*alg.b[1]*integrator.du1 + integrator.dt*alg.b[2]*integrator.du2 + integrator.dt*alg.b[3]*integrator.du3
-                
-                # Already done that for u_tmp1 and u_tmp2, such that they are v1 = u_tmp1 and v2 = u_tmp2
-                # integrator.u_tmp1 .= integrator.u1              
-                # integrator.u_tmp2 .= integrator.u2
-                @. integrator.u_tmp3 = integrator.u3
-                # set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
-                # set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache)
-                set_cons_var_to_zero!(integrator.u_tmp3,semi,solver,cache,equations,mesh)
-
-                @. integrator.u = integrator.u - integrator.dt/relaxation_rate*alg.b[1]*(integrator.u_tmp1 - integrator.fu1) - integrator.dt/relaxation_rate*alg.b[2]*(integrator.u_tmp2 - integrator.fu2) - integrator.dt*alg.b[3]/relaxation_rate*(integrator.u_tmp3 - integrator.fu3)
-                # End Stages   
-          #  for stage_callback in alg.stage_callbacks
-          #      stage_callback(integrator.u, integrator, 1)
-          #  end
+        modify_dt_for_tstops!(integrator)
+        # if the next iteration would push the simulation beyond the end time, set dt accordingly
+        if integrator.t + integrator.dt > t_end ||
+           isapprox(integrator.t + integrator.dt, t_end)
+            integrator.dt = t_end - integrator.t
+            terminate!(integrator)
+        end
+        integrator.u1 .= 0
+        integrator.u2 .= 0
+        integrator.u3 .= 0
+        integrator.du1 .= 0
+        integrator.du2 .= 0
+        integrator.du3 .= 0
+        integrator.fu1 .= 0
+        integrator.fu2 .= 0
+        integrator.fu3 .= 0
+        integrator.u_tmp1 .= 0
+        integrator.u_tmp2 .= 0
+        integrator.u_tmp3 .= 0
+
+        #Ui = Un - dt sum A1_ij partial rhs(Uj) - dt/epsilon sum A2_ij (Vj - f(Uj))
+        #Un+1 = Un - dt sum bj partial rhs(Uj) - dt/epsilon sum bj (Vj - f(Uj))
+
+        t_stage = integrator.t + integrator.dt * alg.c1[1]
+
+        #   Stage 1
+        #Ui = (ui;vi)
+        #u1 = un
+        #v1 = vn - -dt/epsilon A2_{11} (v1 - f(u1)) 
+        @. integrator.u1 = integrator.u  #u1 = v1 = un
+        @. integrator.fu1 = integrator.u1
+        wrap_and_perform_projection!(integrator.fu1, integrator.dt, mesh, equations,
+                                     solver, cache)  # compute f(u1)
+        @. integrator.u1 = integrator.u1 +
+                           integrator.dt / relaxation_rate * alg.A2[1, 1] *
+                           integrator.fu1 # v1 = vn + dt/eps*A2_11 f(u1)
+
+        divide_relaxed_var!(integrator.u1, integrator.dt, semi, solver, cache,
+                            alg.A2[1, 1], equations, mesh)  # v1 = (vn + dt/eps*A2_11 f(u1))/(1 + dt/eps A2_11)
+
+        integrator.f(integrator.du1, integrator.u1, integrator.p, t_stage) # compute RHS(u1,v1)
+
+        # Stage 2        
+        #u2 = un - dt A1_{21} rhs(u1,v1) 
+        #v2 = vn - dt A1_{21} rhs(u1,v1) - dt/epsilon A2_{21} (v1 - f(u1)) -dt/epsilon A2_{22} (v2 - f(u2)) 
+
+        t_stage = integrator.t + integrator.dt * alg.c1[2]
+
+        @. integrator.u2 = integrator.u + integrator.dt * alg.A1[2, 1] * integrator.du1 # u2 = v2 = Un - dt*A1_22 RHS(U1)
+
+        @. integrator.fu2 = integrator.u2
+        wrap_and_perform_projection!(integrator.fu2, integrator.dt, mesh, equations,
+                                     solver, cache) # compute f(u2) and setting the source term values to 0 for the cons variables
+
+        @. integrator.u_tmp1 = integrator.u1
+        set_cons_var_to_zero!(integrator.u_tmp1, semi, solver, cache, equations, mesh) # computing v1 by setting cons variables to 0
+
+        # v2 = vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2)
+        @. integrator.u2 = integrator.u2 -
+                           integrator.dt / relaxation_rate * alg.A2[2, 1] *
+                           (integrator.u_tmp1 - integrator.fu1) +
+                           integrator.dt * alg.A2[2, 2] / relaxation_rate *
+                           integrator.fu2
+
+        divide_relaxed_var!(integrator.u2, integrator.dt, semi, solver, cache,
+                            alg.A2[2, 2], equations, mesh) # v2 = (vn - dt/eps*A2_21*(v1-f(u1)) + dt/eps*A2_22*f(u2) ) ( 1+dt/eps A2_22)
+
+        integrator.f(integrator.du2, integrator.u2, integrator.p, t_stage)
+
+        # Stage 3
+        #u3 = un - dt A1_{31} rhs(u1,v1) - dt A1_{32} rhs(u2,v2)
+        #v3 = vn - dt A1_{31} rhs(u1,v1) - dt A1_{32} rhs(u2,v2) - dt/epsilon A2_{31} (v1 - f(u1)) -dt/epsilon A2_{32} (v2 - f(u2)) -dt/epsilon A2_{33} (v3 - f(u3))
+        @. integrator.u3 = integrator.u +
+                           integrator.dt * alg.A1[3, 1] * integrator.du1 +
+                           integrator.dt * alg.A1[3, 2] * integrator.du2
+
+        @. integrator.fu3 = integrator.u3
+        wrap_and_perform_projection!(integrator.fu3, integrator.dt, mesh, equations,
+                                     solver, cache)
+
+        #  @. integrator.u_tmp1 = integrator.u1
+        #  set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
+
+        @. integrator.u_tmp2 = integrator.u2
+        set_cons_var_to_zero!(integrator.u_tmp2, semi, solver, cache, equations, mesh)
+
+        @. integrator.u3 = integrator.u3 -
+                           integrator.dt / relaxation_rate * alg.A2[3, 1] *
+                           (integrator.u_tmp1 - integrator.fu1) -
+                           integrator.dt / relaxation_rate * alg.A2[3, 2] *
+                           (integrator.u_tmp2 - integrator.fu2) +
+                           integrator.dt * alg.A2[3, 3] / relaxation_rate *
+                           integrator.fu3
+
+        divide_relaxed_var!(integrator.u3, integrator.dt, semi, solver, cache,
+                            alg.A2[3, 3], equations, mesh)
+
+        integrator.f(integrator.du3, integrator.u3, integrator.p, t_stage)
+
+        # Final Stage
+        @. integrator.u = integrator.u + integrator.dt * alg.b[1] * integrator.du1 +
+                          integrator.dt * alg.b[2] * integrator.du2 +
+                          integrator.dt * alg.b[3] * integrator.du3
+
+        # Already done that for u_tmp1 and u_tmp2, such that they are v1 = u_tmp1 and v2 = u_tmp2
+        # integrator.u_tmp1 .= integrator.u1              
+        # integrator.u_tmp2 .= integrator.u2
+        @. integrator.u_tmp3 = integrator.u3
+        # set_cons_var_to_zero!(integrator.u_tmp1,semi,solver,cache)
+        # set_cons_var_to_zero!(integrator.u_tmp2,semi,solver,cache)
+        set_cons_var_to_zero!(integrator.u_tmp3, semi, solver, cache, equations, mesh)
+
+        @. integrator.u = integrator.u -
+                          integrator.dt / relaxation_rate * alg.b[1] *
+                          (integrator.u_tmp1 - integrator.fu1) -
+                          integrator.dt / relaxation_rate * alg.b[2] *
+                          (integrator.u_tmp2 - integrator.fu2) -
+                          integrator.dt * alg.b[3] / relaxation_rate *
+                          (integrator.u_tmp3 - integrator.fu3)
+        # End Stages   
+        #  for stage_callback in alg.stage_callbacks
+        #      stage_callback(integrator.u, integrator, 1)
+        #  end
 
         integrator.iter += 1
         integrator.t += integrator.dt
@@ -328,7 +359,7 @@ function solve!(integrator::SimpleIntegratorIMEX)
                 end
             end
         end
-        
+
         # respect maximum number of iterations
         if integrator.iter >= integrator.opts.maxiters && !integrator.finalstep
             @warn "Interrupted. Larger maxiters is needed."
@@ -348,96 +379,95 @@ function solve!(integrator::SimpleIntegratorIMEX)
                                   (prob.u0, integrator.u), prob)
 end
 
-function divide_relaxed_var!(u,dt,semi,solver,cache,aii,equations,mesh)
-    u_wrap = Trixi.wrap_array(u,semi)
-    cycle_divide!(u_wrap,dt,semi,solver,cache,aii,equations,mesh)
+function divide_relaxed_var!(u, dt, semi, solver, cache, aii, equations, mesh)
+    u_wrap = Trixi.wrap_array(u, semi)
+    cycle_divide!(u_wrap, dt, semi, solver, cache, aii, equations, mesh)
     return nothing
 end
 
-function cycle_divide!(u,dt,semi,solver,cache,aii,equations,mesh::TreeMesh2D)
+function cycle_divide!(u, dt, semi, solver, cache, aii, equations, mesh::TreeMesh2D)
     @unpack inverse_jacobian = cache.elements
-                nvars_base = nvariables(equations.equations_base)
-         relaxation_rate = equations.eps_relaxation
-                for element in eachelement(solver,cache)
-                    factor = inverse_jacobian[element]
-                    #factor = 1.0
-                    for j in eachnode(solver),i in eachnode(solver)
-                        for var in (nvars_base+1):(nvars_base*3)
-                        u[var,i,j,element] = u[var,i,j,element]/(1.0+factor*dt/relaxation_rate*aii)    
-                        end
-                    end
-                end
+    nvars_base = nvariables(equations.equations_base)
+    relaxation_rate = equations.eps_relaxation
+    for element in eachelement(solver, cache)
+        factor = inverse_jacobian[element]
+        #factor = 1.0
+        for j in eachnode(solver), i in eachnode(solver)
+            for var in (nvars_base + 1):(nvars_base * 3)
+                u[var, i, j, element] = u[var, i, j, element] /
+                                        (1.0 + factor * dt / relaxation_rate * aii)
+            end
+        end
+    end
 
     return nothing
 end
 
-
-function cycle_divide!(u,dt,semi,solver,cache,aii,equations,mesh::TreeMesh1D)
+function cycle_divide!(u, dt, semi, solver, cache, aii, equations, mesh::TreeMesh1D)
     @unpack inverse_jacobian = cache.elements
-                nvars_base = nvariables(equations.equations_base)
-         relaxation_rate = equations.eps_relaxation
-                for element in eachelement(solver,cache)
-                    factor = inverse_jacobian[element]
-                    factor = 1.0
-                    for i in eachnode(solver)
-                        for var in (nvars_base+1):(nvars_base*2)
-                        u[var,i,element] = u[var,i,element]/(1.0+factor*dt/relaxation_rate*aii)    
-                        end
-                    end
-                end
+    nvars_base = nvariables(equations.equations_base)
+    relaxation_rate = equations.eps_relaxation
+    for element in eachelement(solver, cache)
+        factor = inverse_jacobian[element]
+        factor = 1.0
+        for i in eachnode(solver)
+            for var in (nvars_base + 1):(nvars_base * 2)
+                u[var, i, element] = u[var, i, element] /
+                                     (1.0 + factor * dt / relaxation_rate * aii)
+            end
+        end
+    end
 
     return nothing
 end
 
-function wrap_and_perform_projection!(u,dt,mesh,equations,solver,cache)
+function wrap_and_perform_projection!(u, dt, mesh, equations, solver, cache)
+    u_wrap = wrap_array(u, mesh, equations, solver, cache)
+    perform_projection_sourceterm!(u_wrap, dt, mesh, equations, solver, cache)
 
-                u_wrap = wrap_array(u, mesh, equations, solver, cache)
-                perform_projection_sourceterm!(u_wrap,dt,mesh,equations,solver,cache)
-    
     return nothing
 end
 
-
-function set_cons_var_to_zero!(u,semi,solver,cache,equations, mesh::TreeMesh2D)
-                u_wrap = Trixi.wrap_array(u,semi)
-                nvars_base = nvariables(equations.equations_base)
+function set_cons_var_to_zero!(u, semi, solver, cache, equations, mesh::TreeMesh2D)
+    u_wrap = Trixi.wrap_array(u, semi)
+    nvars_base = nvariables(equations.equations_base)
     @unpack inverse_jacobian = cache.elements
-                for element in eachelement(solver, cache)    
-                    factor = inverse_jacobian[element]
-                 #   factor = 1.0
-                    for j in eachnode(solver), i in eachnode(solver)
-                        for var in 1:nvars_base
-                           u_wrap[var,i,j,element] = 0.0
-                        end
-                        for var in (nvars_base+1):(nvars_base*3)
-                           u_wrap[var,i,j,element] *= factor 
-                        end
-                    end
-                end
+    for element in eachelement(solver, cache)
+        factor = inverse_jacobian[element]
+        #   factor = 1.0
+        for j in eachnode(solver), i in eachnode(solver)
+            for var in 1:nvars_base
+                u_wrap[var, i, j, element] = 0.0
+            end
+            for var in (nvars_base + 1):(nvars_base * 3)
+                u_wrap[var, i, j, element] *= factor
+            end
+        end
+    end
     return nothing
 end
 
-
-function set_cons_var_to_zero!(u,semi,solver,cache,equations, mesh::TreeMesh1D)
-                u_wrap = Trixi.wrap_array(u,semi)
-                nvars_base = nvariables(equations.equations_base)
+function set_cons_var_to_zero!(u, semi, solver, cache, equations, mesh::TreeMesh1D)
+    u_wrap = Trixi.wrap_array(u, semi)
+    nvars_base = nvariables(equations.equations_base)
     @unpack inverse_jacobian = cache.elements
-                for element in eachelement(solver, cache)    
-                    factor = inverse_jacobian[element]
-                    factor = 1.0
-                    for i in eachnode(solver)
-                        for var in 1:nvars_base
-                           u_wrap[var,i,element] = 0.0
-                        end
-                        for var in (nvars_base+1):(nvars_base*2)
-                           u_wrap[var,i,element] *= factor 
-                        end
-                    end
-                end
+    for element in eachelement(solver, cache)
+        factor = inverse_jacobian[element]
+        factor = 1.0
+        for i in eachnode(solver)
+            for var in 1:nvars_base
+                u_wrap[var, i, element] = 0.0
+            end
+            for var in (nvars_base + 1):(nvars_base * 2)
+                u_wrap[var, i, element] *= factor
+            end
+        end
+    end
     return nothing
 end
 
-function perform_projection_sourceterm!(u, dt, mesh::TreeMesh1D, equations::JinXinEquations, dg, cache)
+function perform_projection_sourceterm!(u, dt, mesh::TreeMesh1D,
+                                        equations::JinXinEquations, dg, cache)
 
     # relaxation parameter
     eps = equations.eps_relaxation
@@ -447,7 +477,7 @@ function perform_projection_sourceterm!(u, dt, mesh::TreeMesh1D, equations::JinX
     @unpack inverse_jacobian = cache.elements
     # prepare local storage for projection
     @unpack interpolate_N_to_M, project_M_to_N, filter_modal_to_N = dg.basis
-    nnodes_,nnodes_projection = size(project_M_to_N)
+    nnodes_, nnodes_projection = size(project_M_to_N)
     nVars = nvariables(eq_relax)
     RealT = real(dg)
     u_N = zeros(RealT, nVars, nnodes_)
@@ -464,66 +494,65 @@ function perform_projection_sourceterm!(u, dt, mesh::TreeMesh1D, equations::JinX
     tmp_MxN = zeros(RealT, nVars, nnodes_projection, nnodes_)
     tmp_NxM = zeros(RealT, nVars, nnodes_, nnodes_projection)
 
-#@threaded for element in eachelement(dg, cache)
-for element in eachelement(dg, cache)
-
-                    factor = inverse_jacobian[element]
-                    factor = 1.0
-# get element u_N
-for i in eachnode(dg)
-    u_node = get_node_vars(u, equations, dg, i, element)
-    for v in eachvariable(eq_relax)
-        u_N[v,i] = u_node[v]
-    end
-end
-# bring elemtn u_N to grid (M+1)x(M+1)
-
-multiply_dimensionwise!(u_M,interpolate_N_to_M,u_N)
-
-# compute nodal values of entropy variables w on the M grid
-for i in 1:nnodes_projection
-    u_cons = get_node_vars(u_M, eq_relax, dg, i)
-    w_ij   = cons2entropy(u_cons,eq_relax) 
-    set_node_vars!(w_M_raw,w_ij,eq_relax,dg,i)
-end
-# compute projection of w with M values down to N
-multiply_dimensionwise!(w_M,filter_modal_to_N,w_M_raw)
-
-#multiply_dimensionwise!(w_N,project_M_to_N,w_M)
-#multiply_dimensionwise!(w_M,interpolate_N_to_M,w_N)
+    #@threaded for element in eachelement(dg, cache)
+    for element in eachelement(dg, cache)
+        factor = inverse_jacobian[element]
+        factor = 1.0
+        # get element u_N
+        for i in eachnode(dg)
+            u_node = get_node_vars(u, equations, dg, i, element)
+            for v in eachvariable(eq_relax)
+                u_N[v, i] = u_node[v]
+            end
+        end
+        # bring elemtn u_N to grid (M+1)x(M+1)
 
+        multiply_dimensionwise!(u_M, interpolate_N_to_M, u_N)
 
-# compute nodal values of conservative f,g on the M grid
-for i in 1:nnodes_projection
-    w_i = get_node_vars(w_M, eq_relax, dg, i)
-    u_cons = entropy2cons(w_i, eq_relax)
-    f_cons = flux(u_cons,1,eq_relax)
-    set_node_vars!(f_M,f_cons,eq_relax,dg,i)
-end
-# compute projection of f with M values down to N, same for g
-multiply_dimensionwise!(f_N,project_M_to_N,f_M)
-#@assert nnodes_projection == nnodes(dg) 
-#for j in 1:nnodes_projection, i in 1:nnodes_projection
-#    u_cons = get_node_vars(u_N, eq_relax, dg, i, j)
-#    f_cons = flux(u_cons,1,eq_relax)
-#    set_node_vars!(f_N,f_cons,eq_relax,dg,i,j)
-#    g_cons = flux(u_cons,2,eq_relax)
-#    set_node_vars!(g_N,g_cons,eq_relax,dg,i,j)
-#end
-
-    for i in eachnode(dg)
-        u_node = get_node_vars(u, equations, dg, i, element)
-        # compute compressible Euler fluxes
-        vu = get_node_vars(f_N,eq_relax,dg,i)
-        u_base = get_block_components2(u_node, 1, equations)
-        new_u = factor*SVector(zero(u_base)..., vu...)
-        set_node_vars!(u, new_u, equations, dg, i, element)
+        # compute nodal values of entropy variables w on the M grid
+        for i in 1:nnodes_projection
+            u_cons = get_node_vars(u_M, eq_relax, dg, i)
+            w_ij = cons2entropy(u_cons, eq_relax)
+            set_node_vars!(w_M_raw, w_ij, eq_relax, dg, i)
+        end
+        # compute projection of w with M values down to N
+        multiply_dimensionwise!(w_M, filter_modal_to_N, w_M_raw)
+
+        #multiply_dimensionwise!(w_N,project_M_to_N,w_M)
+        #multiply_dimensionwise!(w_M,interpolate_N_to_M,w_N)
+
+        # compute nodal values of conservative f,g on the M grid
+        for i in 1:nnodes_projection
+            w_i = get_node_vars(w_M, eq_relax, dg, i)
+            u_cons = entropy2cons(w_i, eq_relax)
+            f_cons = flux(u_cons, 1, eq_relax)
+            set_node_vars!(f_M, f_cons, eq_relax, dg, i)
+        end
+        # compute projection of f with M values down to N, same for g
+        multiply_dimensionwise!(f_N, project_M_to_N, f_M)
+        #@assert nnodes_projection == nnodes(dg) 
+        #for j in 1:nnodes_projection, i in 1:nnodes_projection
+        #    u_cons = get_node_vars(u_N, eq_relax, dg, i, j)
+        #    f_cons = flux(u_cons,1,eq_relax)
+        #    set_node_vars!(f_N,f_cons,eq_relax,dg,i,j)
+        #    g_cons = flux(u_cons,2,eq_relax)
+        #    set_node_vars!(g_N,g_cons,eq_relax,dg,i,j)
+        #end
+
+        for i in eachnode(dg)
+            u_node = get_node_vars(u, equations, dg, i, element)
+            # compute compressible Euler fluxes
+            vu = get_node_vars(f_N, eq_relax, dg, i)
+            u_base = get_block_components2(u_node, 1, equations)
+            new_u = factor * SVector(zero(u_base)..., vu...)
+            set_node_vars!(u, new_u, equations, dg, i, element)
+        end
     end
-end
-return nothing
+    return nothing
 end
 
-function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D, equations::JinXinEquations, dg, cache)
+function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D,
+                                        equations::JinXinEquations, dg, cache)
 
     # relaxation parameter
     eps = equations.eps_relaxation
@@ -533,7 +562,7 @@ function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D, equations::JinX
     @unpack inverse_jacobian = cache.elements
     # prepare local storage for projection
     @unpack interpolate_N_to_M, project_M_to_N, filter_modal_to_N = dg.basis
-    nnodes_,nnodes_projection = size(project_M_to_N)
+    nnodes_, nnodes_projection = size(project_M_to_N)
     nVars = nvariables(eq_relax)
     RealT = real(dg)
     u_N = zeros(RealT, nVars, nnodes_, nnodes_)
@@ -550,66 +579,64 @@ function perform_projection_sourceterm!(u, dt, mesh::TreeMesh2D, equations::JinX
     tmp_MxN = zeros(RealT, nVars, nnodes_projection, nnodes_)
     tmp_NxM = zeros(RealT, nVars, nnodes_, nnodes_projection)
 
-#@threaded for element in eachelement(dg, cache)
-for element in eachelement(dg, cache)
-
-                    factor = inverse_jacobian[element]
-                  #  factor = 1.0
-# get element u_N
-for j in eachnode(dg), i in eachnode(dg)
-    u_node = get_node_vars(u, equations, dg, i, j, element)
-    for v in eachvariable(eq_relax)
-        u_N[v,i,j] = u_node[v]
-    end
-end
-# bring elemtn u_N to grid (M+1)x(M+1)
-multiply_dimensionwise!(u_M,interpolate_N_to_M,u_N,tmp_MxN)
-
-# compute nodal values of entropy variables w on the M grid
-for j in 1:nnodes_projection, i in 1:nnodes_projection
-    u_cons = get_node_vars(u_M, eq_relax, dg, i, j)
-    w_ij   = cons2entropy(u_cons,eq_relax) 
-    set_node_vars!(w_M_raw,w_ij,eq_relax,dg,i,j)
-end
-# compute projection of w with M values down to N
-multiply_dimensionwise!(w_M,filter_modal_to_N,w_M_raw,tmp_MxM)
-
-#multiply_dimensionwise!(w_N,project_M_to_N,w_M)
-#multiply_dimensionwise!(w_M,interpolate_N_to_M,w_N)
-
-
-# compute nodal values of conservative f,g on the M grid
-for j in 1:nnodes_projection, i in 1:nnodes_projection
-    w_ij = get_node_vars(w_M, eq_relax, dg, i, j)
-    u_cons = entropy2cons(w_ij, eq_relax)
-    f_cons = flux(u_cons,1,eq_relax)
-    set_node_vars!(f_M,f_cons,eq_relax,dg,i,j)
-    g_cons = flux(u_cons,2,eq_relax)
-    set_node_vars!(g_M,g_cons,eq_relax,dg,i,j)
-end
-# compute projection of f with M values down to N, same for g
-multiply_dimensionwise!(f_N,project_M_to_N,f_M,tmp_NxM)
-multiply_dimensionwise!(g_N,project_M_to_N,g_M,tmp_NxM)
-#@assert nnodes_projection == nnodes(dg) 
-#for j in 1:nnodes_projection, i in 1:nnodes_projection
-#    u_cons = get_node_vars(u_N, eq_relax, dg, i, j)
-#    f_cons = flux(u_cons,1,eq_relax)
-#    set_node_vars!(f_N,f_cons,eq_relax,dg,i,j)
-#    g_cons = flux(u_cons,2,eq_relax)
-#    set_node_vars!(g_N,g_cons,eq_relax,dg,i,j)
-#end
-
-    for j in eachnode(dg), i in eachnode(dg)
-        u_node = get_node_vars(u, equations, dg, i, j, element)
-        # compute compressible Euler fluxes
-        vu = get_node_vars(f_N,eq_relax,dg,i,j)
-        wu = get_node_vars(g_N,eq_relax,dg,i,j)
-        u_base = get_block_components2(u_node, 1, equations)
-        new_u = factor*SVector(zero(u_base)..., vu..., wu...)
-        set_node_vars!(u, new_u, equations, dg, i, j, element)
+    #@threaded for element in eachelement(dg, cache)
+    for element in eachelement(dg, cache)
+        factor = inverse_jacobian[element]
+        #  factor = 1.0
+        # get element u_N
+        for j in eachnode(dg), i in eachnode(dg)
+            u_node = get_node_vars(u, equations, dg, i, j, element)
+            for v in eachvariable(eq_relax)
+                u_N[v, i, j] = u_node[v]
+            end
+        end
+        # bring elemtn u_N to grid (M+1)x(M+1)
+        multiply_dimensionwise!(u_M, interpolate_N_to_M, u_N, tmp_MxN)
+
+        # compute nodal values of entropy variables w on the M grid
+        for j in 1:nnodes_projection, i in 1:nnodes_projection
+            u_cons = get_node_vars(u_M, eq_relax, dg, i, j)
+            w_ij = cons2entropy(u_cons, eq_relax)
+            set_node_vars!(w_M_raw, w_ij, eq_relax, dg, i, j)
+        end
+        # compute projection of w with M values down to N
+        multiply_dimensionwise!(w_M, filter_modal_to_N, w_M_raw, tmp_MxM)
+
+        #multiply_dimensionwise!(w_N,project_M_to_N,w_M)
+        #multiply_dimensionwise!(w_M,interpolate_N_to_M,w_N)
+
+        # compute nodal values of conservative f,g on the M grid
+        for j in 1:nnodes_projection, i in 1:nnodes_projection
+            w_ij = get_node_vars(w_M, eq_relax, dg, i, j)
+            u_cons = entropy2cons(w_ij, eq_relax)
+            f_cons = flux(u_cons, 1, eq_relax)
+            set_node_vars!(f_M, f_cons, eq_relax, dg, i, j)
+            g_cons = flux(u_cons, 2, eq_relax)
+            set_node_vars!(g_M, g_cons, eq_relax, dg, i, j)
+        end
+        # compute projection of f with M values down to N, same for g
+        multiply_dimensionwise!(f_N, project_M_to_N, f_M, tmp_NxM)
+        multiply_dimensionwise!(g_N, project_M_to_N, g_M, tmp_NxM)
+        #@assert nnodes_projection == nnodes(dg) 
+        #for j in 1:nnodes_projection, i in 1:nnodes_projection
+        #    u_cons = get_node_vars(u_N, eq_relax, dg, i, j)
+        #    f_cons = flux(u_cons,1,eq_relax)
+        #    set_node_vars!(f_N,f_cons,eq_relax,dg,i,j)
+        #    g_cons = flux(u_cons,2,eq_relax)
+        #    set_node_vars!(g_N,g_cons,eq_relax,dg,i,j)
+        #end
+
+        for j in eachnode(dg), i in eachnode(dg)
+            u_node = get_node_vars(u, equations, dg, i, j, element)
+            # compute compressible Euler fluxes
+            vu = get_node_vars(f_N, eq_relax, dg, i, j)
+            wu = get_node_vars(g_N, eq_relax, dg, i, j)
+            u_base = get_block_components2(u_node, 1, equations)
+            new_u = factor * SVector(zero(u_base)..., vu..., wu...)
+            set_node_vars!(u, new_u, equations, dg, i, j, element)
+        end
     end
-end
-return nothing
+    return nothing
 end
 
 function get_block_components2(u, n, equations::JinXinEquations)
@@ -617,7 +644,6 @@ function get_block_components2(u, n, equations::JinXinEquations)
     return SVector(ntuple(i -> u[i + (n - 1) * nvars_base], Val(nvars_base)))
 end
 
-
 # get a cache where the RHS can be stored
 get_du(integrator::SimpleIntegratorIMEX) = integrator.du
 get_tmp_cache(integrator::SimpleIntegratorIMEX) = (integrator.r0,)
diff --git a/test/test_dgmulti_1d.jl b/test/test_dgmulti_1d.jl
index 7ac3c73564..1c3cd604df 100644
--- a/test/test_dgmulti_1d.jl
+++ b/test/test_dgmulti_1d.jl
@@ -52,12 +52,12 @@ end
                         l2=[
                             7.853842541289665e-7,
                             9.609905503440606e-7,
-                            2.832322219966481e-6,
+                            2.832322219966481e-6
                         ] ./ sqrt(2.0),
                         linf=[
                             1.5003758788711963e-6,
                             1.802998748523521e-6,
-                            4.83599270806323e-6,
+                            4.83599270806323e-6
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -76,12 +76,12 @@ end
                         l2=[
                             1.673813320412685,
                             5.980737909458242,
-                            21.587822949251173,
+                            21.587822949251173
                         ],
                         linf=[
                             3.1388039126918064,
                             10.630952212105246,
-                            37.682826521024865,
+                            37.682826521024865
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -117,12 +117,12 @@ end
                         l2=[
                             6.437827414849647e-6,
                             2.1840558851820947e-6,
-                            1.3245669629438228e-5,
+                            1.3245669629438228e-5
                         ],
                         linf=[
                             2.0715843751295537e-5,
                             8.519520630301258e-6,
-                            4.2642194098885255e-5,
+                            4.2642194098885255e-5
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -146,12 +146,12 @@ end
                         l2=[
                             1.8684509287853788e-5,
                             1.0641411823379635e-5,
-                            5.178010291876143e-5,
+                            5.178010291876143e-5
                         ],
                         linf=[
                             6.933493585936645e-5,
                             3.0277366229292113e-5,
-                            0.0002220020568932668,
+                            0.0002220020568932668
                         ])
     show(stdout, semi.solver.basis)
     show(stdout, MIME"text/plain"(), semi.solver.basis)
@@ -169,11 +169,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_fdsbp_periodic.jl"),
                         l2=[
                             9.146929178341782e-7, 1.8997616876521201e-6,
-                            3.991417701005622e-6,
+                            3.991417701005622e-6
                         ],
                         linf=[
                             1.7321089882393892e-6, 3.3252888869128583e-6,
-                            6.525278767988141e-6,
+                            6.525278767988141e-6
                         ])
     show(stdout, semi.solver.basis)
     show(stdout, MIME"text/plain"(), semi.solver.basis)
@@ -210,13 +210,13 @@ end
                             3.03001101100507e-6,
                             1.692177335948727e-5,
                             3.002634351734614e-16,
-                            1.1636653574178203e-15,
+                            1.1636653574178203e-15
                         ],
                         linf=[
                             1.2043401988570679e-5,
                             5.346847010329059e-5,
                             9.43689570931383e-16,
-                            2.220446049250313e-15,
+                            2.220446049250313e-15
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -236,13 +236,13 @@ end
                             1.633271343738687e-5,
                             9.575385661756332e-6,
                             1.2700331443128421e-5,
-                            0.0,
+                            0.0
                         ],
                         linf=[
                             7.304984704381567e-5,
                             5.2365944135601694e-5,
                             6.469559594934893e-5,
-                            0.0,
+                            0.0
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_dgmulti_2d.jl b/test/test_dgmulti_2d.jl
index ab6b505e20..932fb9bc95 100644
--- a/test/test_dgmulti_2d.jl
+++ b/test/test_dgmulti_2d.jl
@@ -23,13 +23,13 @@ isdir(outdir) && rm(outdir, recursive = true)
                             0.0013536930300254945,
                             0.0014315603442106193,
                             0.001431560344211359,
-                            0.0047393341007602625,
+                            0.0047393341007602625
                         ] ./ 2.0,
                         linf=[
                             0.001514260921466004,
                             0.0020623991944839215,
                             0.002062399194485476,
-                            0.004897700392503701,
+                            0.004897700392503701
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -51,13 +51,13 @@ end
                             0.0074706882014934735,
                             0.005306220583603261,
                             0.005306220583613591,
-                            0.014724842607716771,
+                            0.014724842607716771
                         ] ./ 2.0,
                         linf=[
                             0.021563604940952885,
                             0.01359397832530762,
                             0.013593978324845324,
-                            0.03270995869587523,
+                            0.03270995869587523
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -79,13 +79,13 @@ end
                             0.00031892254415307093,
                             0.00033637562986771894,
                             0.0003363756298680649,
-                            0.0011100259064243145,
+                            0.0011100259064243145
                         ] ./ 2.0,
                         linf=[
                             0.001073298211445639,
                             0.0013568139808282087,
                             0.0013568139808290969,
-                            0.0032249020004324613,
+                            0.0032249020004324613
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -107,13 +107,13 @@ end
                             0.007801417730672109,
                             0.00708583561714128,
                             0.0070858356171393,
-                            0.015217574294198809,
+                            0.015217574294198809
                         ] ./ 2.0,
                         linf=[
                             0.011572828457858897,
                             0.013965298735070686,
                             0.01396529873508534,
-                            0.04227683691807904,
+                            0.04227683691807904
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -136,13 +136,13 @@ end
                             0.01280067571168776,
                             0.010607599608273302,
                             0.010607599608239775,
-                            0.026408338014056548,
+                            0.026408338014056548
                         ] ./ 2.0,
                         linf=[
                             0.037983023185674814,
                             0.05321027922533417,
                             0.05321027922608157,
-                            0.13392025411844033,
+                            0.13392025411844033
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -166,13 +166,13 @@ end
                             0.0029373718090697975,
                             0.0030629360605489465,
                             0.003062936060545615,
-                            0.0068486089344859755,
+                            0.0068486089344859755
                         ] ./ 2.0,
                         linf=[
                             0.01360165305316885,
                             0.01267402847925303,
                             0.012674028479251254,
-                            0.02210545278615017,
+                            0.02210545278615017
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -188,11 +188,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_bilinear.jl"),
                         l2=[
                             1.0259432774540821e-5, 9.014087689495575e-6,
-                            9.01408768888544e-6, 2.738953324859446e-5,
+                            9.01408768888544e-6, 2.738953324859446e-5
                         ],
                         linf=[
                             7.362605996297233e-5, 6.874189724781488e-5,
-                            6.874189703509614e-5, 0.00019124355334110277,
+                            6.874189703509614e-5, 0.00019124355334110277
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -208,11 +208,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_curved.jl"),
                         l2=[
                             1.7204593127904542e-5, 1.5921547179522804e-5,
-                            1.5921547180107928e-5, 4.894071422525737e-5,
+                            1.5921547180107928e-5, 4.894071422525737e-5
                         ],
                         linf=[
                             0.00010525416937667842, 0.00010003778102718464,
-                            0.00010003778071832059, 0.0003642628211952825,
+                            0.00010003778071832059, 0.0003642628211952825
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -232,13 +232,13 @@ end
                             3.4666312079259457e-6,
                             3.4392774480368986e-6,
                             3.439277447953705e-6,
-                            1.0965598424665836e-5,
+                            1.0965598424665836e-5
                         ],
                         linf=[
                             1.1327280377004811e-5,
                             1.1343911926253725e-5,
                             1.1343911906935844e-5,
-                            3.679582619220412e-5,
+                            3.679582619220412e-5
                         ],
                         rtol=2 * sqrt(eps()))
     # Ensure that we do not have excessive memory allocations 
@@ -260,13 +260,13 @@ end
                             7.905498158659466e-6,
                             8.731690809663625e-6,
                             8.731690811576996e-6,
-                            2.9113296018693953e-5,
+                            2.9113296018693953e-5
                         ],
                         linf=[
                             3.298811230090237e-5,
                             4.032272476939269e-5,
                             4.032272526011127e-5,
-                            0.00012013725458537294,
+                            0.00012013725458537294
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -284,13 +284,13 @@ end
                             0.0008153911341517156,
                             0.0007768159701964676,
                             0.00047902606811690694,
-                            0.0015551846076348535,
+                            0.0015551846076348535
                         ],
                         linf=[
                             0.0029301131365355726,
                             0.0034427051471457304,
                             0.0028721569841545502,
-                            0.011125365074589944,
+                            0.011125365074589944
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -311,7 +311,7 @@ end
                        4.243843382379403,
                        4.128314378833922,
                        4.128314378397532,
-                       4.081366752807379,
+                       4.081366752807379
                    ], rtol = 0.05)
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -328,11 +328,11 @@ end
                         # division by 2.0 corresponds to normalization by the square root of the size of the domain
                         l2=[
                             0.0007492755162295128, 0.0007641875305302599,
-                            0.0007641875305306243, 0.0024232389721009447,
+                            0.0007641875305306243, 0.0024232389721009447
                         ],
                         linf=[
                             0.0015060064614331736, 0.0019371156800773726,
-                            0.0019371156800769285, 0.004742431684202408,
+                            0.0019371156800769285, 0.004742431684202408
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -348,11 +348,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_triangulate_pkg_mesh.jl"),
                         l2=[
                             2.344076909832665e-6, 1.8610002398709756e-6,
-                            2.4095132179484066e-6, 6.37330249340445e-6,
+                            2.4095132179484066e-6, 6.37330249340445e-6
                         ],
                         linf=[
                             2.509979394305084e-5, 2.2683711321080935e-5,
-                            2.6180377720841363e-5, 5.575278031910713e-5,
+                            2.6180377720841363e-5, 5.575278031910713e-5
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -373,13 +373,13 @@ end
                             0.11140378947116614,
                             0.06598161188703612,
                             0.10448953167839563,
-                            0.16023209181809595,
+                            0.16023209181809595
                         ] ./ 2.0,
                         linf=[
                             0.24033843177853664,
                             0.1659992245272325,
                             0.1235468309508845,
-                            0.26911424973147735,
+                            0.26911424973147735
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -401,13 +401,13 @@ end
                             0.11141270656347146,
                             0.06598888014584121,
                             0.1044902203749932,
-                            0.16023037364774995,
+                            0.16023037364774995
                         ] ./ 2.0,
                         linf=[
                             0.2414760062126462,
                             0.1662111846065654,
                             0.12344140473946856,
-                            0.26978428189564774,
+                            0.26978428189564774
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -425,11 +425,11 @@ end
                         cells_per_dimension=(8, 8), tspan=(0.0, 0.2),
                         l2=[
                             0.07097806723891838, 0.005168550941966817,
-                            0.013820912272220933, 0.03243357220022434,
+                            0.013820912272220933, 0.03243357220022434
                         ],
                         linf=[
                             0.4783395896753895, 0.02244629340135818,
-                            0.04023357731088538, 0.08515807256615027,
+                            0.04023357731088538, 0.08515807256615027
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -448,13 +448,13 @@ end
                             0.006680001611078062,
                             0.02151676347585447,
                             0.010696524235364626,
-                            0.15052841129694647,
+                            0.15052841129694647
                         ],
                         linf=[
                             0.01544756362800248,
                             0.09517304772476806,
                             0.021957154972646383,
-                            0.33773439650806303,
+                            0.33773439650806303
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -473,13 +473,13 @@ end
                             0.05685148333985476,
                             0.04308122135907089,
                             0.043081221359070915,
-                            0.21098131003847664,
+                            0.21098131003847664
                         ],
                         linf=[
                             0.2360672306096051,
                             0.16684417686971842,
                             0.1668441768697189,
-                            0.8572572782118661,
+                            0.8572572782118661
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -498,13 +498,13 @@ end
                             0.05565849298766252,
                             0.042322816017256494,
                             0.042322816017256466,
-                            0.2064212098324083,
+                            0.2064212098324083
                         ],
                         linf=[
                             0.23633287875008924,
                             0.16930148707515683,
                             0.16930148707515688,
-                            0.8587706761131937,
+                            0.8587706761131937
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -532,13 +532,13 @@ end
                             0.0008966318978421226,
                             0.0011418826379110242,
                             0.001141882637910878,
-                            0.0030918374335671393,
+                            0.0030918374335671393
                         ] ./ 2.0,
                         linf=[
                             0.0015281525343109337,
                             0.00162430960401716,
                             0.0016243096040242655,
-                            0.004447503691245913,
+                            0.004447503691245913
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -568,13 +568,13 @@ end
                             0.0014018725496871129,
                             0.0015887007320868913,
                             0.001588700732086329,
-                            0.003870926821031202,
+                            0.003870926821031202
                         ] ./ 2.0,
                         linf=[
                             0.0029541996523780867,
                             0.0034520465226108854,
                             0.003452046522624652,
-                            0.007677153211004928,
+                            0.007677153211004928
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -590,11 +590,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_fdsbp_periodic.jl"),
                         l2=[
                             1.333332033888785e-6, 2.044834627786368e-6,
-                            2.0448346278315884e-6, 5.282189803437435e-6,
+                            2.0448346278315884e-6, 5.282189803437435e-6
                         ],
                         linf=[
                             2.7000151703315822e-6, 3.988595025372632e-6,
-                            3.9885950240403645e-6, 8.848583036513702e-6,
+                            3.9885950240403645e-6, 8.848583036513702e-6
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -614,13 +614,13 @@ end
                             1.333332034149886e-6,
                             2.0448346280892024e-6,
                             2.0448346279766305e-6,
-                            5.282189803510037e-6,
+                            5.282189803510037e-6
                         ],
                         linf=[
                             2.700015170553627e-6,
                             3.988595024262409e-6,
                             3.988595024928543e-6,
-                            8.84858303740188e-6,
+                            8.84858303740188e-6
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -646,13 +646,13 @@ end
                             0.07318831033918516,
                             0.10039910610067465,
                             0.1003991061006748,
-                            0.2642450566234564,
+                            0.2642450566234564
                         ],
                         linf=[
                             0.36081081739439735,
                             0.5244468027020845,
                             0.5244468027020814,
-                            1.2210130256735705,
+                            1.2210130256735705
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -679,13 +679,13 @@ end
                             1.5440402410017893e-5,
                             1.4913189903083485e-5,
                             1.4913189902797073e-5,
-                            2.6104615985156992e-5,
+                            2.6104615985156992e-5
                         ],
                         linf=[
                             4.16334345412217e-5,
                             5.067812788173143e-5,
                             5.067812786885284e-5,
-                            9.887976803746312e-5,
+                            9.887976803746312e-5
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -796,7 +796,7 @@ end
                             0.0018573693138866614,
                             0.0020807798141551166,
                             0.0,
-                            5.301188920230166e-5,
+                            5.301188920230166e-5
                         ],
                         linf=[
                             0.01692601228199253,
@@ -807,7 +807,7 @@ end
                             0.00984964453299233,
                             0.01141708032148614,
                             0.0,
-                            0.0002992631411931389,
+                            0.0002992631411931389
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -827,13 +827,13 @@ end
                             0.0020316462913319046,
                             0.023669019044882247,
                             0.03446194752754684,
-                            1.9333465252381796e-15,
+                            1.9333465252381796e-15
                         ],
                         linf=[
                             0.010385010095182778,
                             0.08750628939565086,
                             0.12088392994348407,
-                            9.325873406851315e-15,
+                            9.325873406851315e-15
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -853,13 +853,13 @@ end
                             0.004180680322490383,
                             0.07026192411558974,
                             0.11815151697006446,
-                            2.329788936151192e-15,
+                            2.329788936151192e-15
                         ],
                         linf=[
                             0.02076003852980346,
                             0.29169601664914424,
                             0.5674183379872275,
-                            1.1546319456101628e-14,
+                            1.1546319456101628e-14
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -881,13 +881,13 @@ end
                             0.0008309356912456799,
                             0.01522451288799231,
                             0.016033969387208476,
-                            1.2820247308150876e-5,
+                            1.2820247308150876e-5
                         ],
                         linf=[
                             0.001888045014140971,
                             0.05466838692127718,
                             0.06345885709961152,
-                            3.3989933098554914e-5,
+                            3.3989933098554914e-5
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
@@ -911,13 +911,13 @@ end
                             7.460461950323111e-5,
                             0.003685589808444905,
                             0.0039101604749887785,
-                            2.0636891126652983e-15,
+                            2.0636891126652983e-15
                         ],
                         linf=[
                             0.000259995400729629,
                             0.0072236204211630906,
                             0.010364675200833062,
-                            1.021405182655144e-14,
+                            1.021405182655144e-14
                         ])
     # Ensure that we do not have excessive memory allocations 
     # (e.g., from type instabilities) 
diff --git a/test/test_dgmulti_3d.jl b/test/test_dgmulti_3d.jl
index fa70b11447..06cda732df 100644
--- a/test/test_dgmulti_3d.jl
+++ b/test/test_dgmulti_3d.jl
@@ -20,12 +20,12 @@ isdir(outdir) && rm(outdir, recursive = true)
                         l2=[
                             0.000354593110864001, 0.00041301573702385284,
                             0.00037934556184883277, 0.0003525767114354012,
-                            0.0013917457634530887,
+                            0.0013917457634530887
                         ],
                         linf=[
                             0.0036608123230692513, 0.005625540942772123,
                             0.0030565781898950206, 0.004158099048202857,
-                            0.01932716837214299,
+                            0.01932716837214299
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -47,14 +47,14 @@ end
                             0.017080219613061526,
                             0.016589517840793006,
                             0.015905000907070196,
-                            0.03903416208587798,
+                            0.03903416208587798
                         ] ./ sqrt(8),
                         linf=[
                             0.06856547797256729,
                             0.08225664880340489,
                             0.06925055630951782,
                             0.06913016119820181,
-                            0.19161418499621874,
+                            0.19161418499621874
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -76,14 +76,14 @@ end
                             0.00040146357607439464,
                             0.00040146357607564597,
                             0.000401463576075708,
-                            0.0015749412434154315,
+                            0.0015749412434154315
                         ] ./ sqrt(8),
                         linf=[
                             0.00036910287847780054,
                             0.00042659774184228283,
                             0.0004265977427213574,
                             0.00042659774250686233,
-                            0.00143803344597071,
+                            0.00143803344597071
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -100,11 +100,11 @@ end
                         l2=[
                             0.01835488304593566, 0.024412704052042534,
                             0.02440852041608929, 0.018163145708800853,
-                            0.03934280550797125,
+                            0.03934280550797125
                         ],
                         linf=[
                             0.14862225990793032, 0.2895236816183626, 0.291205448481636,
-                            0.14566031338563246, 0.33153545867790246,
+                            0.14566031338563246, 0.33153545867790246
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -122,12 +122,12 @@ end
                         l2=[
                             0.0026311315195097097, 0.002914422404496567,
                             0.0029138891106640368, 0.002615140832315232,
-                            0.006881528610616624,
+                            0.006881528610616624
                         ],
                         linf=[
                             0.02099611487415931, 0.021314522450152307,
                             0.021288322783027613, 0.020273381695449455,
-                            0.05259874039006007,
+                            0.05259874039006007
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -144,12 +144,12 @@ end
                         l2=[
                             0.00036475807571383924, 0.00043404536371780537,
                             0.0003985850214093045, 0.0003683451584072326,
-                            0.00143503620472638,
+                            0.00143503620472638
                         ],
                         linf=[
                             0.0032278615418719347, 0.005620238272054934,
                             0.0030514261010661237, 0.0039871165455998,
-                            0.019282771780667396,
+                            0.019282771780667396
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -171,14 +171,14 @@ end
                             0.00044397204714598747,
                             0.0004439720471461567,
                             0.0004439720471464591,
-                            0.0016639410646990126,
+                            0.0016639410646990126
                         ] ./ sqrt(8),
                         linf=[
                             0.0003674374460325147,
                             0.0004253921341716982,
                             0.0004253921340786615,
                             0.0004253921340831024,
-                            0.0014333414071048267,
+                            0.0014333414071048267
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -202,14 +202,14 @@ end
                             0.002491315550718859,
                             0.0024913155507195303,
                             0.002491315550720031,
-                            0.008585818982343299,
+                            0.008585818982343299
                         ] ./ sqrt(8),
                         linf=[
                             0.003810078279323559,
                             0.004998778644230928,
                             0.004998778643986235,
                             0.0049987786444081195,
-                            0.016455044373650196,
+                            0.016455044373650196
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -229,14 +229,14 @@ end
                             0.06219350883951729,
                             0.062193508839503864,
                             0.08121963221634831,
-                            0.07082703570808184,
+                            0.07082703570808184
                         ],
                         linf=[
                             0.0007893509649821162,
                             0.1481953939988877,
                             0.14819539399791176,
                             0.14847291108358926,
-                            0.21313533492212855,
+                            0.21313533492212855
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -257,14 +257,14 @@ end
                             0.062193508839511434,
                             0.06219350883949677,
                             0.08121963221635205,
-                            0.07082703570765223,
+                            0.07082703570765223
                         ],
                         linf=[
                             0.000789350964946367,
                             0.14819539399525805,
                             0.14819539399590542,
                             0.14847291107658706,
-                            0.21313533492059378,
+                            0.21313533492059378
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -291,14 +291,14 @@ end
                             0.003318758964118284,
                             0.0033187589641182386,
                             0.003318758964118252,
-                            0.012689348410504253,
+                            0.012689348410504253
                         ],
                         linf=[
                             0.006118565824207778,
                             0.008486456080185167,
                             0.008486456080180282,
                             0.008486456080185611,
-                            0.035113544599208346,
+                            0.035113544599208346
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -327,14 +327,14 @@ end
                             0.004944363692625066,
                             0.0049443636926250435,
                             0.004944363692625037,
-                            0.01788695279620914,
+                            0.01788695279620914
                         ],
                         linf=[
                             0.013861851418853988,
                             0.02126572106620328,
                             0.021265721066209053,
                             0.021265721066210386,
-                            0.0771455289446683,
+                            0.0771455289446683
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -353,14 +353,14 @@ end
                             6.884047859361093e-5,
                             6.884047859363204e-5,
                             6.884047859361148e-5,
-                            0.000201107274617457,
+                            0.000201107274617457
                         ],
                         linf=[
                             0.0001337520020225913,
                             0.00011571467799287305,
                             0.0001157146779990903,
                             0.00011571467799376123,
-                            0.0003446082308800058,
+                            0.0003446082308800058
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_mpi_p4est_2d.jl b/test/test_mpi_p4est_2d.jl
index 6d66bc68a2..605099a8dd 100644
--- a/test/test_mpi_p4est_2d.jl
+++ b/test/test_mpi_p4est_2d.jl
@@ -136,13 +136,13 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "p4est_2d_dgsem")
                                 0.0034516244508588046,
                                 0.0023420334036925493,
                                 0.0024261923964557187,
-                                0.004731710454271893,
+                                0.004731710454271893
                             ],
                             linf=[
                                 0.04155789011775046,
                                 0.024772109862748914,
                                 0.03759938693042297,
-                                0.08039824959535657,
+                                0.08039824959535657
                             ])
 
         # Ensure that we do not have excessive memory allocations
diff --git a/test/test_mpi_p4est_3d.jl b/test/test_mpi_p4est_3d.jl
index cca9093ec5..5b34476aa1 100644
--- a/test/test_mpi_p4est_3d.jl
+++ b/test/test_mpi_p4est_3d.jl
@@ -129,14 +129,14 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "p4est_3d_dgsem")
                                 4.4993257426833716e-5,
                                 5.10588457841744e-5,
                                 5.102840924036687e-5,
-                                0.00019986264001630542,
+                                0.00019986264001630542
                             ],
                             linf=[
                                 0.0016987332417202072,
                                 0.003622956808262634,
                                 0.002029576258317789,
                                 0.0024206977281964193,
-                                0.008526972236273522,
+                                0.008526972236273522
                             ],
                             tspan=(0.0, 0.01))
 
@@ -158,14 +158,14 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "p4est_3d_dgsem")
                                 0.0014733349038567685,
                                 0.00147333490385685,
                                 0.001473334903856929,
-                                0.0028149479453087093,
+                                0.0028149479453087093
                             ],
                             linf=[
                                 0.008070806335238156,
                                 0.009007245083113125,
                                 0.009007245083121784,
                                 0.009007245083102688,
-                                0.01562861968368434,
+                                0.01562861968368434
                             ],
                             tspan=(0.0, 1.0))
 
@@ -186,14 +186,14 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "p4est_3d_dgsem")
                                 0.006192950051354618,
                                 0.005970674274073704,
                                 0.005965831290564327,
-                                0.02628875593094754,
+                                0.02628875593094754
                             ],
                             linf=[
                                 0.3326911600075694,
                                 0.2824952141320467,
                                 0.41401037398065543,
                                 0.45574161423218573,
-                                0.8099577682187109,
+                                0.8099577682187109
                             ],
                             tspan=(0.0, 0.2),
                             coverage_override=(polydeg = 3,)) # Prevent long compile time in CI
@@ -216,14 +216,14 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "p4est_3d_dgsem")
                                 0.004122532789279737,
                                 0.0042448149597303616,
                                 0.0036361316700401765,
-                                0.007389845952982495,
+                                0.007389845952982495
                             ],
                             linf=[
                                 0.04530610539892499,
                                 0.02765695110527666,
                                 0.05670295599308606,
                                 0.048396544302230504,
-                                0.1154589758186293,
+                                0.1154589758186293
                             ])
 
         # Ensure that we do not have excessive memory allocations
diff --git a/test/test_mpi_t8code_2d.jl b/test/test_mpi_t8code_2d.jl
index 7c7fc03898..5bd5f41c7f 100644
--- a/test/test_mpi_t8code_2d.jl
+++ b/test/test_mpi_t8code_2d.jl
@@ -118,13 +118,13 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "t8code_2d_dgsem")
                                 0.0034516244508588046,
                                 0.0023420334036925493,
                                 0.0024261923964557187,
-                                0.004731710454271893,
+                                0.004731710454271893
                             ],
                             linf=[
                                 0.04155789011775046,
                                 0.024772109862748914,
                                 0.03759938693042297,
-                                0.08039824959535657,
+                                0.08039824959535657
                             ])
 
         # Ensure that we do not have excessive memory allocations
diff --git a/test/test_mpi_t8code_3d.jl b/test/test_mpi_t8code_3d.jl
index a15690a762..b8fe4b29a6 100644
--- a/test/test_mpi_t8code_3d.jl
+++ b/test/test_mpi_t8code_3d.jl
@@ -96,14 +96,14 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "t8code_3d_dgsem")
                                 4.4993257426833716e-5,
                                 5.10588457841744e-5,
                                 5.102840924036687e-5,
-                                0.00019986264001630542,
+                                0.00019986264001630542
                             ],
                             linf=[
                                 0.0016987332417202072,
                                 0.003622956808262634,
                                 0.002029576258317789,
                                 0.0024206977281964193,
-                                0.008526972236273522,
+                                0.008526972236273522
                             ],
                             tspan=(0.0, 0.01))
 
@@ -125,14 +125,14 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "t8code_3d_dgsem")
                                 0.0014733349038567685,
                                 0.00147333490385685,
                                 0.001473334903856929,
-                                0.0028149479453087093,
+                                0.0028149479453087093
                             ],
                             linf=[
                                 0.008070806335238156,
                                 0.009007245083113125,
                                 0.009007245083121784,
                                 0.009007245083102688,
-                                0.01562861968368434,
+                                0.01562861968368434
                             ],
                             tspan=(0.0, 1.0))
 
@@ -153,14 +153,14 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "t8code_3d_dgsem")
                                 0.006192950051354618,
                                 0.005970674274073704,
                                 0.005965831290564327,
-                                0.02628875593094754,
+                                0.02628875593094754
                             ],
                             linf=[
                                 0.3326911600075694,
                                 0.2824952141320467,
                                 0.41401037398065543,
                                 0.45574161423218573,
-                                0.8099577682187109,
+                                0.8099577682187109
                             ],
                             tspan=(0.0, 0.2),
                             coverage_override=(polydeg = 3,)) # Prevent long compile time in CI
diff --git a/test/test_mpi_tree.jl b/test/test_mpi_tree.jl
index 6351a405b5..611df97780 100644
--- a/test/test_mpi_tree.jl
+++ b/test/test_mpi_tree.jl
@@ -104,12 +104,12 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                 l2=[
                                     0.00015687751816056159,
                                     0.001025986772217084,
-                                    0.0010259867722169909,
+                                    0.0010259867722169909
                                 ],
                                 linf=[
                                     0.0011986956416591976,
                                     0.006423873516411049,
-                                    0.006423873516411049,
+                                    0.006423873516411049
                                 ])
         end
     end
@@ -120,12 +120,12 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                             l2=[
                                 8.61813235543625e-8,
                                 5.619399844542781e-7,
-                                5.6193998447443e-7,
+                                5.6193998447443e-7
                             ],
                             linf=[
                                 1.124861862180196e-6,
                                 8.622436471039663e-6,
-                                8.622436470151484e-6,
+                                8.622436470151484e-6
                             ])
     end
 
@@ -134,12 +134,12 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                             l2=[
                                 8.523077653955306e-6,
                                 2.8779323653065056e-5,
-                                5.4549427691297846e-5,
+                                5.4549427691297846e-5
                             ],
                             linf=[
                                 5.5227409524905013e-5,
                                 0.0001454489597927185,
-                                0.00032396328684569653,
+                                0.00032396328684569653
                             ])
     end
 
@@ -149,12 +149,12 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                 l2=[
                                     5.868147556427088e-6,
                                     3.80517927324465e-5,
-                                    3.805179273249344e-5,
+                                    3.805179273249344e-5
                                 ],
                                 linf=[
                                     3.701965498725812e-5,
                                     0.0002122422943138247,
-                                    0.00021224229431116015,
+                                    0.00021224229431116015
                                 ],
                                 atol=2.0e-12) #= required for CI on macOS =#
         end
@@ -170,13 +170,13 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                     9.321181253186009e-7,
                                     1.4181210743438511e-6,
                                     1.4181210743487851e-6,
-                                    4.824553091276693e-6,
+                                    4.824553091276693e-6
                                 ],
                                 linf=[
                                     9.577246529612893e-6,
                                     1.1707525976012434e-5,
                                     1.1707525976456523e-5,
-                                    4.8869615580926506e-5,
+                                    4.8869615580926506e-5
                                 ],
                                 rtol=2000 * sqrt(eps()))
         end
@@ -191,13 +191,13 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                     4.8226610349853444e-5,
                                     4.117706709270575e-5,
                                     4.1177067092959676e-5,
-                                    0.00012205252427437389,
+                                    0.00012205252427437389
                                 ],
                                 linf=[
                                     0.0003543874851490436,
                                     0.0002973166773747593,
                                     0.0002973166773760916,
-                                    0.001154106793870291,
+                                    0.001154106793870291
                                 ],
                                 # Let this test run until the end to cover the time-dependent lines
                                 # of the indicator and the MPI-specific AMR code.
@@ -213,13 +213,13 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                     2.259440511766445e-6,
                                     2.318888155713922e-6,
                                     2.3188881557894307e-6,
-                                    6.3327863238858925e-6,
+                                    6.3327863238858925e-6
                                 ],
                                 linf=[
                                     1.498738264560373e-5,
                                     1.9182011928187137e-5,
                                     1.918201192685487e-5,
-                                    6.0526717141407005e-5,
+                                    6.0526717141407005e-5
                                 ],
                                 rtol=0.001)
         end
@@ -232,13 +232,13 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                     0.061751715597716854,
                                     0.05018223615408711,
                                     0.05018989446443463,
-                                    0.225871559730513,
+                                    0.225871559730513
                                 ],
                                 linf=[
                                     0.29347582879608825,
                                     0.31081249232844693,
                                     0.3107380389947736,
-                                    1.0540358049885143,
+                                    1.0540358049885143
                                 ])
 
             @testset "error-based step size control" begin
@@ -255,13 +255,13 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                         0.061653630426688116,
                         0.05006930431098764,
                         0.05007694316484242,
-                        0.22550689872331683,
+                        0.22550689872331683
                     ] rtol=1.0e-4
                     @test errors.linf≈[
                         0.28516937484583693,
                         0.2983633696512788,
                         0.297812036335975,
-                        1.027368795517512,
+                        1.027368795517512
                     ] rtol=1.0e-4
                 end
             end
@@ -274,13 +274,13 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                 0.00013492249515826863,
                                 0.006615696236378061,
                                 0.006782108219800376,
-                                0.016393831451740604,
+                                0.016393831451740604
                             ],
                             linf=[
                                 0.0020782600954247776,
                                 0.08150078921935999,
                                 0.08663621974991986,
-                                0.2829930622010579,
+                                0.2829930622010579
                             ],
                             rtol=0.001)
     end
@@ -292,13 +292,13 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                 0.0017208369388227673,
                                 0.09628684992237334,
                                 0.09620157717330868,
-                                0.1758809552387432,
+                                0.1758809552387432
                             ],
                             linf=[
                                 0.021869936355319086,
                                 0.9956698009442038,
                                 1.0002507727219028,
-                                2.223249697515648,
+                                2.223249697515648
                             ])
     end
 
@@ -309,13 +309,13 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                 5.051719943432265e-5,
                                 0.0022574259317084747,
                                 0.0021755998463189713,
-                                0.004346492398617521,
+                                0.004346492398617521
                             ],
                             linf=[
                                 0.0012880114865917447,
                                 0.03857193149447702,
                                 0.031090457959835893,
-                                0.12125130332971423,
+                                0.12125130332971423
                             ],
                             coverage_override=(maxiters = 6,))
     end
@@ -328,13 +328,13 @@ CI_ON_WINDOWS = (get(ENV, "GITHUB_ACTIONS", false) == "true") && Sys.iswindows()
                                     0.0017158367642679273,
                                     0.09619888722871434,
                                     0.09616432767924141,
-                                    0.17553381166255197,
+                                    0.17553381166255197
                                 ],
                                 linf=[
                                     0.021853862449723982,
                                     0.9878047229255944,
                                     0.9880191167111795,
-                                    2.2154030488035588,
+                                    2.2154030488035588
                                 ],
                                 rtol=0.001)
         end
diff --git a/test/test_p4est_2d.jl b/test/test_p4est_2d.jl
index fbc94fdfd6..242ed2eeee 100644
--- a/test/test_p4est_2d.jl
+++ b/test/test_p4est_2d.jl
@@ -115,13 +115,13 @@ end
                             0.0034516244508588046,
                             0.0023420334036925493,
                             0.0024261923964557187,
-                            0.004731710454271893,
+                            0.004731710454271893
                         ],
                         linf=[
                             0.04155789011775046,
                             0.024772109862748914,
                             0.03759938693042297,
-                            0.08039824959535657,
+                            0.08039824959535657
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -139,7 +139,7 @@ end
                             2.063350241405049e-15,
                             1.8571016296925367e-14,
                             3.1769447886391905e-14,
-                            1.4104095258528071e-14,
+                            1.4104095258528071e-14
                         ],
                         linf=[1.9539925233402755e-14, 2e-12, 4.8e-12, 4e-12],
                         atol=2.0e-12,)
@@ -159,13 +159,13 @@ end
                             9.53984675e-02,
                             1.05633455e-01,
                             1.05636158e-01,
-                            3.50747237e-01,
+                            3.50747237e-01
                         ],
                         linf=[
                             2.94357464e-01,
                             4.07893014e-01,
                             3.97334516e-01,
-                            1.08142520e+00,
+                            1.08142520e+00
                         ],
                         tspan=(0.0, 1.0))
     # Ensure that we do not have excessive memory allocations
@@ -184,13 +184,13 @@ end
                             0.09527896382082567,
                             0.10557894830184737,
                             0.10559379376154387,
-                            0.3503791205165925,
+                            0.3503791205165925
                         ],
                         linf=[
                             0.2733486454092644,
                             0.3877283966722886,
                             0.38650482703821426,
-                            1.0053712251056308,
+                            1.0053712251056308
                         ],
                         tspan=(0.0, 1.0),
                         volume_flux=flux_chandrashekar)
@@ -210,13 +210,13 @@ end
                             3.76149952e-01,
                             2.46970327e-01,
                             2.46970327e-01,
-                            1.28889042e+00,
+                            1.28889042e+00
                         ],
                         linf=[
                             1.22139001e+00,
                             1.17742626e+00,
                             1.17742626e+00,
-                            6.20638482e+00,
+                            6.20638482e+00
                         ],
                         tspan=(0.0, 0.3))
     # Ensure that we do not have excessive memory allocations
@@ -235,13 +235,13 @@ end
                             0.4229948321239887,
                             0.2559038337457483,
                             0.2559038337457484,
-                            1.2990046683564136,
+                            1.2990046683564136
                         ],
                         linf=[
                             1.4989357969730492,
                             1.325456585141623,
                             1.3254565851416251,
-                            6.331283015053501,
+                            6.331283015053501
                         ],
                         surface_flux=flux_hllc,
                         tspan=(0.0, 0.3))
@@ -261,13 +261,13 @@ end
                             0.40853279043747015,
                             0.25356771650524296,
                             0.2535677165052422,
-                            1.2984601729572691,
+                            1.2984601729572691
                         ],
                         linf=[
                             1.3840909333784284,
                             1.3077772519086124,
                             1.3077772519086157,
-                            6.298798630968632,
+                            6.298798630968632
                         ],
                         surface_flux=flux_hlle,
                         tspan=(0.0, 0.3))
@@ -287,13 +287,13 @@ end
                             6.32183914e-01,
                             3.86914231e-01,
                             3.86869171e-01,
-                            1.06575688e+00,
+                            1.06575688e+00
                         ],
                         linf=[
                             2.76020890e+00,
                             2.32659890e+00,
                             2.32580837e+00,
-                            2.15778188e+00,
+                            2.15778188e+00
                         ],
                         tspan=(0.0, 0.3),
                         coverage_override=(maxiters = 6,))
@@ -313,13 +313,13 @@ end
                             0.020291447969983396,
                             0.017479614254319948,
                             0.011387644425613437,
-                            0.0514420126021293,
+                            0.0514420126021293
                         ],
                         linf=[
                             0.3582779022370579,
                             0.32073537890751663,
                             0.221818049107692,
-                            0.9209559420400415,
+                            0.9209559420400415
                         ],
                         tspan=(0.0, 0.15))
     # Ensure that we do not have excessive memory allocations
@@ -338,13 +338,13 @@ end
                             0.004194875320833303,
                             0.003785140699353966,
                             0.0013696609105790351,
-                            0.03265268616046424,
+                            0.03265268616046424
                         ],
                         linf=[
                             2.0585399781442852,
                             2.213428805506876,
                             3.862362410419163,
-                            17.75187237459251,
+                            17.75187237459251
                         ],
                         tspan=(0.0, 0.0001),
                         rtol=1.0e-7,
@@ -367,13 +367,13 @@ end
                             0.051359355290192046,
                             0.4266034859911273,
                             0.2438304855475594,
-                            4.11487176105527,
+                            4.11487176105527
                         ],
                         linf=[
                             6.902000373057003,
                             53.95714139820832,
                             24.241610279839758,
-                            561.0630401858057,
+                            561.0630401858057
                         ],
                         tspan=(0.0, 0.0001),
                         skip_coverage=true)
@@ -395,13 +395,13 @@ end
                             0.026798021911954406,
                             0.05118546368109259,
                             0.03206703583774831,
-                            0.19680026567208672,
+                            0.19680026567208672
                         ],
                         linf=[
                             3.653905721692421,
                             4.285035711361009,
                             6.8544353186357645,
-                            31.748244912257533,
+                            31.748244912257533
                         ],
                         tspan=(0.0, 0.001),
                         skip_coverage=true)
@@ -421,11 +421,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_NACA6412airfoil_mach2.jl"),
                         l2=[
                             0.19107654776276498, 0.3545913719444839,
-                            0.18492730895077583, 0.817927213517244,
+                            0.18492730895077583, 0.817927213517244
                         ],
                         linf=[
                             2.5397624311491946, 2.7075156425517917, 2.200980534211764,
-                            9.031153939238115,
+                            9.031153939238115
                         ],
                         tspan=(0.0, 0.1))
     # Ensure that we do not have excessive memory allocations
@@ -444,13 +444,13 @@ end
                             0.00024871265138964204,
                             0.0003370077102132591,
                             0.0003370077102131964,
-                            0.0007231525513793697,
+                            0.0007231525513793697
                         ],
                         linf=[
                             0.0015813032944647087,
                             0.0020494288423820173,
                             0.0020494288423824614,
-                            0.004793821195083758,
+                            0.004793821195083758
                         ],
                         tspan=(0.0, 0.1))
     # Ensure that we do not have excessive memory allocations
@@ -469,13 +469,13 @@ end
                             9.168126407325352e-5,
                             0.0009795410115453788,
                             0.002546408320320785,
-                            3.941189812642317e-6,
+                            3.941189812642317e-6
                         ],
                         linf=[
                             0.0009903782521019089,
                             0.0059752684687262025,
                             0.010941106525454103,
-                            1.2129488214718265e-5,
+                            1.2129488214718265e-5
                         ],
                         tspan=(0.0, 0.1))
     # Ensure that we do not have excessive memory allocations
@@ -540,13 +540,13 @@ end
                             0.006047938590548741,
                             0.0040953286019907035,
                             0.004222698522497298,
-                            0.006269492499336128,
+                            0.006269492499336128
                         ],
                         linf=[
                             0.06386175207349379,
                             0.0378926444850457,
                             0.041759728067967065,
-                            0.06430136016259067,
+                            0.06430136016259067
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -564,13 +564,13 @@ end
                             0.00011914390523852561,
                             0.00010776028621724485,
                             6.139954358305467e-5,
-                            0.0003067693731825959,
+                            0.0003067693731825959
                         ],
                         linf=[
                             0.1653075586200805,
                             0.1868437275544909,
                             0.09772818519679008,
-                            0.4311796171737692,
+                            0.4311796171737692
                         ], tspan=(0.0, 0.001))
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -601,11 +601,11 @@ end
                                  "elixir_euler_NACA0012airfoil_mach085.jl"),
                         l2=[
                             5.371568111383228e-7, 6.4158131303956445e-6,
-                            1.0324346542348325e-5, 0.0006348064933187732,
+                            1.0324346542348325e-5, 0.0006348064933187732
                         ],
                         linf=[
                             0.0016263400091978443, 0.028471072159724428,
-                            0.02986133204785877, 1.9481060511014872,
+                            0.02986133204785877, 1.9481060511014872
                         ],
                         base_level=0, med_level=1, max_level=1,
                         tspan=(0.0, 0.0001),
diff --git a/test/test_p4est_3d.jl b/test/test_p4est_3d.jl
index 7483cde275..e99440871d 100644
--- a/test/test_p4est_3d.jl
+++ b/test/test_p4est_3d.jl
@@ -132,14 +132,14 @@ end
                             4.4993257426833716e-5,
                             5.10588457841744e-5,
                             5.102840924036687e-5,
-                            0.00019986264001630542,
+                            0.00019986264001630542
                         ],
                         linf=[
                             0.0016987332417202072,
                             0.003622956808262634,
                             0.002029576258317789,
                             0.0024206977281964193,
-                            0.008526972236273522,
+                            0.008526972236273522
                         ],
                         tspan=(0.0, 0.01))
     # Ensure that we do not have excessive memory allocations
@@ -160,14 +160,14 @@ end
                             0.0014733349038567685,
                             0.00147333490385685,
                             0.001473334903856929,
-                            0.0028149479453087093,
+                            0.0028149479453087093
                         ],
                         linf=[
                             0.008070806335238156,
                             0.009007245083113125,
                             0.009007245083121784,
                             0.009007245083102688,
-                            0.01562861968368434,
+                            0.01562861968368434
                         ],
                         tspan=(0.0, 1.0))
     # Ensure that we do not have excessive memory allocations
@@ -187,14 +187,14 @@ end
                             1.941857343642486e-14,
                             2.0232366394187278e-14,
                             2.3381518645408552e-14,
-                            7.083114561232324e-14,
+                            7.083114561232324e-14
                         ],
                         linf=[
                             7.269740365245525e-13,
                             3.289868377720495e-12,
                             4.440087186807773e-12,
                             3.8686831516088205e-12,
-                            9.412914891981927e-12,
+                            9.412914891981927e-12
                         ],
                         tspan=(0.0, 0.03))
     # Ensure that we do not have excessive memory allocations
@@ -214,14 +214,14 @@ end
                             4.889826056731442e-15,
                             2.2921260987087585e-15,
                             4.268460455702414e-15,
-                            1.1356712092620279e-14,
+                            1.1356712092620279e-14
                         ],
                         linf=[
                             7.749356711883593e-14,
                             2.8792246364872653e-13,
                             1.1121659149182506e-13,
                             3.3228975127030935e-13,
-                            9.592326932761353e-13,
+                            9.592326932761353e-13
                         ],
                         tspan=(0.0, 0.1))
     # Ensure that we do not have excessive memory allocations
@@ -240,12 +240,12 @@ end
                         l2=[
                             6.530157034651212e-16, 1.6057829680004379e-15,
                             3.31107455378537e-15, 3.908829498281281e-15,
-                            5.048390610424672e-15,
+                            5.048390610424672e-15
                         ],
                         linf=[
                             4.884981308350689e-15, 1.1921019726912618e-14,
                             1.5432100042289676e-14, 2.298161660974074e-14,
-                            6.039613253960852e-14,
+                            6.039613253960852e-14
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -264,14 +264,14 @@ end
                             4.889826056731442e-15,
                             2.2921260987087585e-15,
                             4.268460455702414e-15,
-                            1.1356712092620279e-14,
+                            1.1356712092620279e-14
                         ],
                         linf=[
                             7.749356711883593e-14,
                             4.513472928735496e-13,
                             2.9790059308254513e-13,
                             1.057154364048074e-12,
-                            1.6271428648906294e-12,
+                            1.6271428648906294e-12
                         ],
                         tspan=(0.0, 0.1),
                         surface_flux=flux_hllc)
@@ -292,14 +292,14 @@ end
                             0.006192950051354618,
                             0.005970674274073704,
                             0.005965831290564327,
-                            0.02628875593094754,
+                            0.02628875593094754
                         ],
                         linf=[
                             0.3326911600075694,
                             0.2824952141320467,
                             0.41401037398065543,
                             0.45574161423218573,
-                            0.8099577682187109,
+                            0.8099577682187109
                         ],
                         tspan=(0.0, 0.2),
                         coverage_override=(polydeg = 3,)) # Prevent long compile time in CI
@@ -320,14 +320,14 @@ end
                             0.006216054794583285,
                             0.006020401857347216,
                             0.006019175682769779,
-                            0.026228080232814154,
+                            0.026228080232814154
                         ],
                         linf=[
                             0.3169376449662026,
                             0.28950510175646726,
                             0.4402523227566396,
                             0.4869168122387365,
-                            0.7999141641954051,
+                            0.7999141641954051
                         ],
                         tspan=(0.0, 0.2),
                         volume_flux=flux_chandrashekar,
@@ -349,14 +349,14 @@ end
                             4.33260474e-02,
                             4.33260474e-02,
                             4.33260474e-02,
-                            3.75260911e-01,
+                            3.75260911e-01
                         ],
                         linf=[
                             7.45329845e-01,
                             3.21754792e-01,
                             3.21754792e-01,
                             3.21754792e-01,
-                            4.76151527e+00,
+                            4.76151527e+00
                         ],
                         tspan=(0.0, 0.3),
                         coverage_override=(polydeg = 3,)) # Prevent long compile time in CI
@@ -377,14 +377,14 @@ end
                             0.04863386374672001,
                             0.048633863746720116,
                             0.04863386374672032,
-                            0.3751015774232693,
+                            0.3751015774232693
                         ],
                         linf=[
                             0.789241521871487,
                             0.42046970270100276,
                             0.42046970270100276,
                             0.4204697027010028,
-                            4.730877375538398,
+                            4.730877375538398
                         ],
                         tspan=(0.0, 0.3),
                         surface_flux=flux_hlle)
@@ -406,14 +406,14 @@ end
                             5.4254175153621895e-6,
                             5.677698851333843e-6,
                             5.8017136892469794e-6,
-                            1.3637854615117974e-5,
+                            1.3637854615117974e-5
                         ],
                         linf=[
                             0.00013996924184311865,
                             0.00013681539559939893,
                             0.00013681539539733834,
                             0.00013681539541021692,
-                            0.00016833038543762058,
+                            0.00016833038543762058
                         ],
                         # Decrease tolerance of adaptive time stepping to get similar results across different systems
                         abstol=1.0e-11, reltol=1.0e-11,
@@ -436,14 +436,14 @@ end
                             3.8630261900166194e-5,
                             3.8672287531936816e-5,
                             3.6865116098660796e-5,
-                            0.05508620970403884,
+                            0.05508620970403884
                         ],
                         linf=[
                             2.268845333053271e-6,
                             0.000531462302113539,
                             0.0005314624461298934,
                             0.0005129931254772464,
-                            0.7942778058932163,
+                            0.7942778058932163
                         ],
                         tspan=(0.0, 2e2),
                         coverage_override=(trees_per_cube_face = (1, 1), polydeg = 3)) # Prevent long compile time in CI
@@ -465,14 +465,14 @@ end
                             0.00021710076010951073,
                             0.0004386796338203878,
                             0.00020836270267103122,
-                            0.07601887903440395,
+                            0.07601887903440395
                         ],
                         linf=[
                             1.9107530539574924e-5,
                             0.02980358831035801,
                             0.048476331898047564,
                             0.02200137344113612,
-                            4.848310144356219,
+                            4.848310144356219
                         ],
                         tspan=(0.0, 1e2),
                         # Decrease tolerance of adaptive time stepping to get similar results across different systems
@@ -496,14 +496,14 @@ end
                             0.004122532789279737,
                             0.0042448149597303616,
                             0.0036361316700401765,
-                            0.007389845952982495,
+                            0.007389845952982495
                         ],
                         linf=[
                             0.04530610539892499,
                             0.02765695110527666,
                             0.05670295599308606,
                             0.048396544302230504,
-                            0.1154589758186293,
+                            0.1154589758186293
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -571,11 +571,11 @@ end
                         l2=[
                             0.04452389418193219, 0.03688186699434862,
                             0.03688186699434861, 0.03688186699434858,
-                            0.044523894181932186,
+                            0.044523894181932186
                         ],
                         linf=[
                             0.2295447498696467, 0.058369658071546704,
-                            0.05836965807154648, 0.05836965807154648, 0.2295447498696468,
+                            0.05836965807154648, 0.05836965807154648, 0.2295447498696468
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_paper_self_gravitating_gas_dynamics.jl b/test/test_paper_self_gravitating_gas_dynamics.jl
index 10b4f93ad7..63a7a2b6de 100644
--- a/test/test_paper_self_gravitating_gas_dynamics.jl
+++ b/test/test_paper_self_gravitating_gas_dynamics.jl
@@ -21,13 +21,13 @@ const EXAMPLES_DIR = pkgdir(Trixi, "examples", "paper_self_gravitating_gas_dynam
                             0.0001740977055972079,
                             0.0003369355182519592,
                             0.0003369355182518708,
-                            0.0006099171220334989,
+                            0.0006099171220334989
                         ],
                         linf=[
                             0.001079347149189669,
                             0.0018836938381321389,
                             0.001883693838132583,
-                            0.003971575376718217,
+                            0.003971575376718217
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -45,13 +45,13 @@ end
                             1.7187201161597772e-5,
                             2.678065111772951e-5,
                             2.678065111783027e-5,
-                            4.952504160091526e-5,
+                            4.952504160091526e-5
                         ],
                         linf=[
                             0.0001501749544159381,
                             0.00016549482504535362,
                             0.00016549482504601976,
-                            0.0004372960291432193,
+                            0.0004372960291432193
                         ],
                         polydeg=4)
     # Ensure that we do not have excessive memory allocations
@@ -69,12 +69,12 @@ end
                         l2=[
                             0.003154024896093942,
                             0.012394432074951856,
-                            0.02185973823794725,
+                            0.02185973823794725
                         ],
                         linf=[
                             0.01731850928579215,
                             0.07843510773347553,
-                            0.11242300176349201,
+                            0.11242300176349201
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -91,12 +91,12 @@ end
                         l2=[
                             0.0002511283012128458,
                             0.0008808243846610255,
-                            0.0016313343228567005,
+                            0.0016313343228567005
                         ],
                         linf=[
                             0.0017290715087938668,
                             0.003129184465704738,
-                            0.01000728849316701,
+                            0.01000728849316701
                         ],
                         polydeg=4)
     # Ensure that we do not have excessive memory allocations
@@ -115,13 +115,13 @@ end
                             0.00024871265138964204,
                             0.0003370077102132591,
                             0.0003370077102131964,
-                            0.0007231525513793697,
+                            0.0007231525513793697
                         ],
                         linf=[
                             0.0015813032944647087,
                             0.0020494288423820173,
                             0.0020494288423824614,
-                            0.004793821195083758,
+                            0.004793821195083758
                         ],
                         tspan=(0.0, 0.1))
     # Ensure that we do not have excessive memory allocations
@@ -140,13 +140,13 @@ end
                             1.9537712148648045e-5,
                             2.7564396197947587e-5,
                             2.7564396197967635e-5,
-                            5.688838772067586e-5,
+                            5.688838772067586e-5
                         ],
                         linf=[
                             0.00012335710672761735,
                             0.00020086268350816283,
                             0.00020086268350727465,
-                            0.0004962155455632278,
+                            0.0004962155455632278
                         ],
                         tspan=(0.0, 0.1), polydeg=4)
     # Ensure that we do not have excessive memory allocations
@@ -165,13 +165,13 @@ end
                             0.00024871265138959434,
                             0.000337007710281087,
                             0.0003370077102811394,
-                            0.0007231525515231289,
+                            0.0007231525515231289
                         ],
                         linf=[
                             0.0015813032941613958,
                             0.002049428843978518,
                             0.0020494288439798503,
-                            0.004793821198143977,
+                            0.004793821198143977
                         ],
                         tspan=(0.0, 0.1),
                         timestep_gravity=Trixi.timestep_gravity_erk51_3Sstar!)
@@ -191,13 +191,13 @@ end
                             0.0002487126513894034,
                             0.00033700771023049785,
                             0.00033700771023048245,
-                            0.0007231525514158737,
+                            0.0007231525514158737
                         ],
                         linf=[
                             0.0015813032943847727,
                             0.002049428842844314,
                             0.0020494288428452023,
-                            0.004793821195971937,
+                            0.004793821195971937
                         ],
                         tspan=(0.0, 0.1),
                         timestep_gravity=Trixi.timestep_gravity_erk53_3Sstar!)
@@ -218,13 +218,13 @@ end
                             10733.63378538114,
                             13356.780607423452,
                             1.6722844879795038e-6,
-                            26834.076821148774,
+                            26834.076821148774
                         ],
                         linf=[
                             15194.296424901113,
                             18881.481685044182,
                             6.809726988008751e-6,
-                            37972.99700513482,
+                            37972.99700513482
                         ],
                         tspan=(0.0, 0.1),
                         atol=4.0e-6)
@@ -245,13 +245,13 @@ end
                             10734.598193238024,
                             13358.217234481384,
                             1.911011743371934e-6,
-                            26836.487841241516,
+                            26836.487841241516
                         ],
                         linf=[
                             15195.661004798487,
                             18883.512035906537,
                             7.867948710816926e-6,
-                            37976.408478975296,
+                            37976.408478975296
                         ],
                         tspan=(0.0, 0.1),
                         atol=4.0e-6, # the background field is reatively large, so this corresponds to our usual atol
@@ -304,13 +304,13 @@ end
                             0.046315994852653024,
                             0.0650818006233669,
                             0.06508180062336677,
-                            0.4896707211656037,
+                            0.4896707211656037
                         ],
                         linf=[
                             2.3874843337593776,
                             4.07876384374792,
                             4.07876384374792,
-                            16.23914384809855,
+                            16.23914384809855
                         ],
                         tspan=(0.0, 0.05),
                         coverage_override=(maxiters = 2,))
@@ -331,13 +331,13 @@ end
                             0.00289222135995042,
                             0.013724813590853825,
                             0.013724813590853832,
-                            0.05822904710548214,
+                            0.05822904710548214
                         ],
                         linf=[
                             0.26361780693997594,
                             1.3908873830688688,
                             1.3908873830688688,
-                            4.066701303607613,
+                            4.066701303607613
                         ],
                         tspan=(0.0, 0.005), initial_refinement_level=8,
                         amr_callback=TrivialCallback())
diff --git a/test/test_parabolic_1d.jl b/test/test_parabolic_1d.jl
index 38bebdcce1..062e6363a2 100644
--- a/test/test_parabolic_1d.jl
+++ b/test/test_parabolic_1d.jl
@@ -67,12 +67,12 @@ end
                         l2=[
                             0.0001133835907077494,
                             6.226282245610444e-5,
-                            0.0002820171699999139,
+                            0.0002820171699999139
                         ],
                         linf=[
                             0.0006255102377159538,
                             0.00036195501456059986,
-                            0.0016147729485886941,
+                            0.0016147729485886941
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -94,12 +94,12 @@ end
                         l2=[
                             0.00011310615871043463,
                             6.216495207074201e-5,
-                            0.00028195843110817814,
+                            0.00028195843110817814
                         ],
                         linf=[
                             0.0006240837363233886,
                             0.0003616694320713876,
-                            0.0016147339542413874,
+                            0.0016147339542413874
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -117,12 +117,12 @@ end
                         l2=[
                             0.00047023310868269237,
                             0.00032181736027057234,
-                            0.0014966266486095025,
+                            0.0014966266486095025
                         ],
                         linf=[
                             0.002996375101363302,
                             0.0028639041695096433,
-                            0.012691132694550689,
+                            0.012691132694550689
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -144,12 +144,12 @@ end
                         l2=[
                             0.0004608500483647771,
                             0.00032431091222851285,
-                            0.0015159733360626845,
+                            0.0015159733360626845
                         ],
                         linf=[
                             0.002754803146635787,
                             0.0028567713744625124,
-                            0.012941793784197131,
+                            0.012941793784197131
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -170,12 +170,12 @@ end
                         l2=[
                             2.5278845598681636e-5,
                             2.5540145802666872e-5,
-                            0.0001211867535580826,
+                            0.0001211867535580826
                         ],
                         linf=[
                             0.0001466387202588848,
                             0.00019422419092429135,
-                            0.0009556449835592673,
+                            0.0009556449835592673
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -197,12 +197,12 @@ end
                         l2=[
                             2.4593521887223632e-5,
                             2.3928212900127102e-5,
-                            0.00011252332663824173,
+                            0.00011252332663824173
                         ],
                         linf=[
                             0.00011850494672183132,
                             0.00018987676556476442,
-                            0.0009597461727750556,
+                            0.0009597461727750556
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_parabolic_2d.jl b/test/test_parabolic_2d.jl
index 7749a0c478..c69030fa50 100644
--- a/test/test_parabolic_2d.jl
+++ b/test/test_parabolic_2d.jl
@@ -127,13 +127,13 @@ end
                             0.0015355076812510957,
                             0.0033843168272696756,
                             0.0036531858107443434,
-                            0.009948436427519214,
+                            0.009948436427519214
                         ],
                         linf=[
                             0.005522560467190019,
                             0.013425258500730508,
                             0.013962115643482154,
-                            0.027483102120502423,
+                            0.027483102120502423
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -153,13 +153,13 @@ end
                             0.004255101916146187,
                             0.011118488923215765,
                             0.011281831283462686,
-                            0.03573656447388509,
+                            0.03573656447388509
                         ],
                         linf=[
                             0.015071710669706473,
                             0.04103132025858458,
                             0.03990424085750277,
-                            0.1309401718598764,
+                            0.1309401718598764
                         ],)
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -179,13 +179,13 @@ end
                             0.00022156125227115747,
                             0.028318325921401,
                             0.009509168701070296,
-                            0.028267900513550506,
+                            0.028267900513550506
                         ],
                         linf=[
                             0.001562278941298234,
                             0.14886653390744856,
                             0.0716323565533752,
-                            0.19472785105241996,
+                            0.19472785105241996
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -276,13 +276,13 @@ end
                             0.002111672530658797,
                             0.0034322351490857846,
                             0.0038742528195910416,
-                            0.012469246082568561,
+                            0.012469246082568561
                         ],
                         linf=[
                             0.012006418939223495,
                             0.035520871209746126,
                             0.024512747492231427,
-                            0.11191122588756564,
+                            0.11191122588756564
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -306,13 +306,13 @@ end
                             0.002103629650383915,
                             0.003435843933396454,
                             0.00386735987813341,
-                            0.012670355349235728,
+                            0.012670355349235728
                         ],
                         linf=[
                             0.012006261793147788,
                             0.03550212518982032,
                             0.025107947319661185,
-                            0.11647078036571124,
+                            0.11647078036571124
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -333,13 +333,13 @@ end
                             0.0021403742517389513,
                             0.0034258287094908572,
                             0.0038915122886898517,
-                            0.012506862343013842,
+                            0.012506862343013842
                         ],
                         linf=[
                             0.012244412004628336,
                             0.03507559186162224,
                             0.024580892345558894,
-                            0.11425600758350107,
+                            0.11425600758350107
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -364,13 +364,13 @@ end
                             0.0021349737347844907,
                             0.0034301388278203033,
                             0.0038928324474291572,
-                            0.012693611436230873,
+                            0.012693611436230873
                         ],
                         linf=[
                             0.01224423627586213,
                             0.035054066314102905,
                             0.025099598504931965,
-                            0.11795616324751634,
+                            0.11795616324751634
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -391,13 +391,13 @@ end
                             0.0021116725306633594,
                             0.0034322351490827557,
                             0.0038742528196093542,
-                            0.012469246082526909,
+                            0.012469246082526909
                         ],
                         linf=[
                             0.012006418939291663,
                             0.035520871209594115,
                             0.024512747491801577,
-                            0.11191122588591007,
+                            0.11191122588591007
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -454,13 +454,13 @@ end
                             0.00015144571529699053,
                             0.018766076072331623,
                             0.007065070765652574,
-                            0.0208399005734258,
+                            0.0208399005734258
                         ],
                         linf=[
                             0.0014523369373669048,
                             0.12366779944955864,
                             0.05532450997115432,
-                            0.16099927805328207,
+                            0.16099927805328207
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -479,13 +479,13 @@ end
                             0.005155557460409018,
                             0.4048446934219344,
                             0.43040068852937047,
-                            1.1255130552079322,
+                            1.1255130552079322
                         ],
                         linf=[
                             0.03287305649809613,
                             1.1656793717431393,
                             1.3917196016246969,
-                            8.146587380114653,
+                            8.146587380114653
                         ],
                         tspan=(0.0, 0.7))
 end
@@ -497,13 +497,13 @@ end
                             0.001452856280034929,
                             0.0007538775539989481,
                             0.0007538775539988681,
-                            0.011035506549989587,
+                            0.011035506549989587
                         ],
                         linf=[
                             0.003291912841311362,
                             0.002986462478096974,
                             0.0029864624780958637,
-                            0.0231954665514138,
+                            0.0231954665514138
                         ],
                         tspan=(0.0, 1.0))
 end
@@ -616,13 +616,13 @@ end
                             0.0003811978985836709,
                             0.0005874314969169538,
                             0.0009142898787923481,
-                            0.0011613918899727263,
+                            0.0011613918899727263
                         ],
                         linf=[
                             0.0021633623982135752,
                             0.009484348274135372,
                             0.004231572066492217,
-                            0.011661660275365193,
+                            0.011661660275365193
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -642,13 +642,13 @@ end
                             0.00040364962558511795,
                             0.0005869762481506936,
                             0.00091488537427274,
-                            0.0011984191566376762,
+                            0.0011984191566376762
                         ],
                         linf=[
                             0.0024993634941723464,
                             0.009487866203944725,
                             0.004505829506628117,
-                            0.011634902776245681,
+                            0.011634902776245681
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -668,13 +668,13 @@ end
                             0.00028716166408816073,
                             0.08101204560401647,
                             0.02099595625377768,
-                            0.05008149754143295,
+                            0.05008149754143295
                         ],
                         linf=[
                             0.014804500261322406,
                             0.9513271652357098,
                             0.7223919625994717,
-                            1.4846907331004786,
+                            1.4846907331004786
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -692,11 +692,11 @@ end
                         tspan=(0.0, 1.0),
                         l2=[
                             0.0005323841980601085, 0.07892044543547208,
-                            0.02909671646389337, 0.11717468256112017,
+                            0.02909671646389337, 0.11717468256112017
                         ],
                         linf=[
                             0.006045292737899444, 0.9233292581786228,
-                            0.7982129977236198, 1.6864546235292153,
+                            0.7982129977236198, 1.6864546235292153
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_parabolic_3d.jl b/test/test_parabolic_3d.jl
index 863daeeaf3..2690a08cbb 100644
--- a/test/test_parabolic_3d.jl
+++ b/test/test_parabolic_3d.jl
@@ -21,14 +21,14 @@ isdir(outdir) && rm(outdir, recursive = true)
                             0.000659263490965341,
                             0.0007776436127362806,
                             0.0006592634909662951,
-                            0.0038073628897809185,
+                            0.0038073628897809185
                         ],
                         linf=[
                             0.0017039861523615585,
                             0.002628561703560073,
                             0.003531057425112172,
                             0.0026285617036090336,
-                            0.015587829540351095,
+                            0.015587829540351095
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -49,14 +49,14 @@ end
                             0.0021322235533273513,
                             0.0027873741447455194,
                             0.0024587473070627423,
-                            0.00997836818019202,
+                            0.00997836818019202
                         ],
                         linf=[
                             0.006341750402837576,
                             0.010306014252246865,
                             0.01520740250924979,
                             0.010968264045485565,
-                            0.047454389831591115,
+                            0.047454389831591115
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -77,14 +77,14 @@ end
                             0.015589736382772248,
                             0.015589736382771884,
                             0.021943924667273653,
-                            0.01927370280244222,
+                            0.01927370280244222
                         ],
                         linf=[
                             0.0006268463584697681,
                             0.03218881662749007,
                             0.03218881662697948,
                             0.053872495395614256,
-                            0.05183822000984151,
+                            0.05183822000984151
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -105,14 +105,14 @@ end
                             0.002653449504302844,
                             0.002898264205184629,
                             0.002653449504302853,
-                            0.009511572365085706,
+                            0.009511572365085706
                         ],
                         linf=[
                             0.013680656759085918,
                             0.0356910450154318,
                             0.023526343547736236,
                             0.035691045015431855,
-                            0.11482570604041165,
+                            0.11482570604041165
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -137,14 +137,14 @@ end
                             0.0026554367897028506,
                             0.002892730402724066,
                             0.002655436789702817,
-                            0.009596351796609566,
+                            0.009596351796609566
                         ],
                         linf=[
                             0.013680508110645473,
                             0.035673446359424356,
                             0.024024936779729028,
                             0.03567344635942474,
-                            0.11839497110809383,
+                            0.11839497110809383
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -166,14 +166,14 @@ end
                             0.0026524750946399327,
                             0.00290860030832445,
                             0.0026524750946399396,
-                            0.009509568981439294,
+                            0.009509568981439294
                         ],
                         linf=[
                             0.01387936112914212,
                             0.03526260609304053,
                             0.023554197097368997,
                             0.035262606093040896,
-                            0.11719963716509518,
+                            0.11719963716509518
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -199,14 +199,14 @@ end
                             0.002654768259143932,
                             0.002907031063651286,
                             0.002654768259143901,
-                            0.009587792882971452,
+                            0.009587792882971452
                         ],
                         linf=[
                             0.01387919380137137,
                             0.035244084526358944,
                             0.02398614622061363,
                             0.03524408452635828,
-                            0.12005056512506407,
+                            0.12005056512506407
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -228,14 +228,14 @@ end
                             0.002653449504301736,
                             0.0028982642051960006,
                             0.0026534495043017384,
-                            0.009511572364811033,
+                            0.009511572364811033
                         ],
                         linf=[
                             0.013680656758949583,
                             0.035691045015224444,
                             0.02352634354676752,
                             0.035691045015223424,
-                            0.11482570603751441,
+                            0.11482570603751441
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -273,14 +273,14 @@ end
         0.0006473493036803503,
         0.0007705277238213672,
         0.0006280517917198335,
-        0.000903927789884075,
+        0.000903927789884075
     ]
     @test linf_error ≈ [
         0.0023694155365339142,
         0.010634932622402863,
         0.006772070862236412,
         0.010640551561726901,
-        0.019256819038719897,
+        0.019256819038719897
     ]
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -301,14 +301,14 @@ end
                             0.015684268393762454,
                             0.01568426839376248,
                             0.021991909545192333,
-                            0.02825413672911425,
+                            0.02825413672911425
                         ],
                         linf=[
                             0.0008410587892853094,
                             0.04740176181772552,
                             0.04740176181772507,
                             0.07483494924031157,
-                            0.150181591534448,
+                            0.150181591534448
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -348,14 +348,14 @@ end
         0.006266480163542894,
         0.006266489911815533,
         0.008829222305770226,
-        0.0032859166842329228,
+        0.0032859166842329228
     ]
     @test linf_error ≈ [
         0.0002943968186086554,
         0.013876261980614757,
         0.013883619864959451,
         0.025201279960491936,
-        0.018679364985388247,
+        0.018679364985388247
     ]
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -377,14 +377,14 @@ end
                             0.000461877794472316,
                             0.0005424899076052261,
                             0.0004618777944723191,
-                            0.0015846392581126832,
+                            0.0015846392581126832
                         ],
                         linf=[
                             0.0025241668929956163,
                             0.006308461681816373,
                             0.004334939663169113,
                             0.006308461681804009,
-                            0.03176343480493493,
+                            0.03176343480493493
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -406,14 +406,14 @@ end
                             0.015637861347119624,
                             0.015637861347119687,
                             0.022024699158522523,
-                            0.009711013505930812,
+                            0.009711013505930812
                         ],
                         linf=[
                             0.0006696415247340326,
                             0.03442565722527785,
                             0.03442565722577423,
                             0.06295407168705314,
-                            0.032857472756916195,
+                            0.032857472756916195
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -464,14 +464,14 @@ end
                             0.03437058632045721,
                             0.03437058632045671,
                             0.041038898400430075,
-                            0.30978593009044153,
+                            0.30978593009044153
                         ],
                         linf=[
                             0.004173569912012121,
                             0.09168674832979556,
                             0.09168674832975021,
                             0.12129218723807476,
-                            0.8433893297612087,
+                            0.8433893297612087
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -490,11 +490,11 @@ end
                         l2=[
                             0.009472104410520866, 0.0017883742549557149,
                             0.0017883742549557147, 0.0017883742549557196,
-                            0.024388540048562748,
+                            0.024388540048562748
                         ],
                         linf=[
                             0.6782397526873181, 0.17663702154066238,
-                            0.17663702154066266, 0.17663702154066238, 1.7327849844825238,
+                            0.17663702154066266, 0.17663702154066238, 1.7327849844825238
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_structured_1d.jl b/test/test_structured_1d.jl
index f97696d089..7e2150245a 100644
--- a/test/test_structured_1d.jl
+++ b/test/test_structured_1d.jl
@@ -79,7 +79,7 @@ end
                         linf=[
                             3.1661064228547255,
                             0.16256363944708607,
-                            2.667676158812806,
+                            2.667676158812806
                         ],
                         tspan=(0.0, 12.5),
                         surface_flux=FluxHLL(min_max_speed_davis))
@@ -99,12 +99,12 @@ end
                         l2=[
                             2.2527950196212703e-8,
                             1.8187357193835156e-8,
-                            7.705669939973104e-8,
+                            7.705669939973104e-8
                         ],
                         linf=[
                             1.6205433861493646e-7,
                             1.465427772462391e-7,
-                            5.372255111879554e-7,
+                            5.372255111879554e-7
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -122,12 +122,12 @@ end
                         l2=[
                             3.8099996914101204e-6,
                             1.6745575717106341e-6,
-                            7.732189531480852e-6,
+                            7.732189531480852e-6
                         ],
                         linf=[
                             1.2971473393186272e-5,
                             9.270328934274374e-6,
-                            3.092514399671842e-5,
+                            3.092514399671842e-5
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_structured_2d.jl b/test/test_structured_2d.jl
index 4b3aa5c87e..41d271eae8 100644
--- a/test/test_structured_2d.jl
+++ b/test/test_structured_2d.jl
@@ -35,13 +35,13 @@ end
                             7.816742843336293e-6,
                             7.816742843340186e-6,
                             7.816742843025513e-6,
-                            7.816742843061526e-6,
+                            7.816742843061526e-6
                         ],
                         linf=[
                             6.314906965276812e-5,
                             6.314906965187994e-5,
                             6.31490696496595e-5,
-                            6.314906965032563e-5,
+                            6.314906965032563e-5
                         ],
                         coverage_override=(maxiters = 10^5,))
 
@@ -51,13 +51,13 @@ end
             7.816742843336293e-6,
             7.816742843340186e-6,
             7.816742843025513e-6,
-            7.816742843061526e-6,
+            7.816742843061526e-6
         ] rtol=1.0e-4
         @test errors.linf≈[
             6.314906965276812e-5,
             6.314906965187994e-5,
             6.31490696496595e-5,
-            6.314906965032563e-5,
+            6.314906965032563e-5
         ] rtol=1.0e-4
         # Ensure that we do not have excessive memory allocations
         # (e.g., from type instabilities)
@@ -74,11 +74,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_advection_meshview.jl"),
                         l2=[
                             8.311947673083206e-6,
-                            8.311947673068427e-6,
+                            8.311947673068427e-6
                         ],
                         linf=[
                             6.627000273318195e-5,
-                            6.62700027264096e-5,
+                            6.62700027264096e-5
                         ],
                         coverage_override=(maxiters = 10^5,))
 
@@ -296,14 +296,14 @@ end
                             1.51236516273878e-5,
                             2.4544918394022538e-5,
                             5.904791661362391e-6,
-                            1.1809583322724782e-5,
+                            1.1809583322724782e-5
                         ],
                         linf=[
                             8.393471747591974e-5,
                             8.393471748258108e-5,
                             0.00015028562494778797,
                             3.504466610437795e-5,
-                            7.00893322087559e-5,
+                            7.00893322087559e-5
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -322,13 +322,13 @@ end
                             9.321181253186009e-7,
                             1.4181210743438511e-6,
                             1.4181210743487851e-6,
-                            4.824553091276693e-6,
+                            4.824553091276693e-6
                         ],
                         linf=[
                             9.577246529612893e-6,
                             1.1707525976012434e-5,
                             1.1707525976456523e-5,
-                            4.8869615580926506e-5,
+                            4.8869615580926506e-5
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -349,13 +349,13 @@ end
                                 9.321181253186009e-7,
                                 1.4181210743438511e-6,
                                 1.4181210743487851e-6,
-                                4.824553091276693e-6,
+                                4.824553091276693e-6
                             ],
                             linf=[
                                 9.577246529612893e-6,
                                 1.1707525976012434e-5,
                                 1.1707525976456523e-5,
-                                4.8869615580926506e-5,
+                                4.8869615580926506e-5
                             ],
                             alpha=0.0)
         # Ensure that we do not have excessive memory allocations
@@ -376,13 +376,13 @@ end
                                 9.321188057029291e-7,
                                 1.3195106906473365e-6,
                                 1.510307360354032e-6,
-                                4.82455408101712e-6,
+                                4.82455408101712e-6
                             ],
                             linf=[
                                 9.57723626271445e-6,
                                 1.0480225511866337e-5,
                                 1.2817828088262928e-5,
-                                4.886962393513272e-5,
+                                4.886962393513272e-5
                             ],
                             alpha=0.1)
         # Ensure that we do not have excessive memory allocations
@@ -403,13 +403,13 @@ end
                                 9.32127973957391e-7,
                                 8.477824799744325e-7,
                                 1.8175286311402784e-6,
-                                4.824562453521076e-6,
+                                4.824562453521076e-6
                             ],
                             linf=[
                                 9.576898420737834e-6,
                                 5.057704352218195e-6,
                                 1.635260719945464e-5,
-                                4.886978754825577e-5,
+                                4.886978754825577e-5
                             ],
                             alpha=0.2 * pi)
         # Ensure that we do not have excessive memory allocations
@@ -430,13 +430,13 @@ end
                                 9.321181253186009e-7,
                                 1.4181210743438511e-6,
                                 1.4181210743487851e-6,
-                                4.824553091276693e-6,
+                                4.824553091276693e-6
                             ],
                             linf=[
                                 9.577246529612893e-6,
                                 1.1707525976012434e-5,
                                 1.1707525976456523e-5,
-                                4.8869615580926506e-5,
+                                4.8869615580926506e-5
                             ],
                             alpha=0.5 * pi)
         # Ensure that we do not have excessive memory allocations
@@ -457,13 +457,13 @@ end
                             1.1167802955144833e-5,
                             1.0805775514153104e-5,
                             1.953188337010932e-5,
-                            5.5033856574857146e-5,
+                            5.5033856574857146e-5
                         ],
                         linf=[
                             8.297006495561199e-5,
                             8.663281475951301e-5,
                             0.00012264160606778596,
-                            0.00041818802502024965,
+                            0.00041818802502024965
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -482,13 +482,13 @@ end
                             2.991891317562739e-5,
                             3.6063177168283174e-5,
                             2.7082941743640572e-5,
-                            0.00011414695350996946,
+                            0.00011414695350996946
                         ],
                         linf=[
                             0.0002437454930492855,
                             0.0003438936171968887,
                             0.00024217622945688078,
-                            0.001266380414757684,
+                            0.001266380414757684
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -506,13 +506,13 @@ end
                             2.063350241405049e-15,
                             1.8571016296925367e-14,
                             3.1769447886391905e-14,
-                            1.4104095258528071e-14,
+                            1.4104095258528071e-14
                         ],
                         linf=[
                             1.9539925233402755e-14,
                             2.9791447087035294e-13,
                             6.502853810985698e-13,
-                            2.7000623958883807e-13,
+                            2.7000623958883807e-13
                         ],
                         atol=7.0e-13)
     # Ensure that we do not have excessive memory allocations
@@ -532,13 +532,13 @@ end
                             2.063350241405049e-15,
                             1.8571016296925367e-14,
                             3.1769447886391905e-14,
-                            1.4104095258528071e-14,
+                            1.4104095258528071e-14
                         ],
                         linf=[
                             1.9539925233402755e-14,
                             2.9791447087035294e-13,
                             6.502853810985698e-13,
-                            2.7000623958883807e-13,
+                            2.7000623958883807e-13
                         ],
                         atol=7.0e-13)
     # Ensure that we do not have excessive memory allocations
@@ -558,13 +558,13 @@ end
                             2.259440511901724e-6,
                             2.3188881559075347e-6,
                             2.3188881559568146e-6,
-                            6.332786324137878e-6,
+                            6.332786324137878e-6
                         ],
                         linf=[
                             1.4987382622067003e-5,
                             1.918201192063762e-5,
                             1.918201192019353e-5,
-                            6.052671713430158e-5,
+                            6.052671713430158e-5
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -582,13 +582,13 @@ end
                             0.03774907669925568,
                             0.02845190575242045,
                             0.028262802829412605,
-                            0.13785915638851698,
+                            0.13785915638851698
                         ],
                         linf=[
                             0.3368296929764073,
                             0.27644083771519773,
                             0.27990039685141377,
-                            1.1971436487402016,
+                            1.1971436487402016
                         ],
                         tspan=(0.0, 0.3))
     # Ensure that we do not have excessive memory allocations
@@ -607,13 +607,13 @@ end
                             3.69856202e-01,
                             2.35242180e-01,
                             2.41444928e-01,
-                            1.28807120e+00,
+                            1.28807120e+00
                         ],
                         linf=[
                             1.82786223e+00,
                             1.30452904e+00,
                             1.40347257e+00,
-                            6.21791658e+00,
+                            6.21791658e+00
                         ],
                         tspan=(0.0, 0.3))
     # Ensure that we do not have excessive memory allocations
@@ -633,13 +633,13 @@ end
                             0.6337774834710513,
                             0.30377119245852724,
                             0.3111372568571772,
-                            1.2976221893997268,
+                            1.2976221893997268
                         ],
                         linf=[
                             2.2064877103138207,
                             1.541067099687334,
                             1.5487587769900337,
-                            6.271271639873466,
+                            6.271271639873466
                         ],
                         tspan=(0.0, 0.5))
     # Ensure that we do not have excessive memory allocations
@@ -663,13 +663,13 @@ end
                             0.7869912572385168,
                             0.39170886758882073,
                             0.39613257454431977,
-                            1.2951760266455101,
+                            1.2951760266455101
                         ],
                         linf=[
                             5.156044534854053,
                             3.6261667239538986,
                             3.1807681416546085,
-                            6.3028422220287235,
+                            6.3028422220287235
                         ],
                         tspan=(0.0, 0.5))
     # Ensure that we do not have excessive memory allocations
@@ -687,11 +687,11 @@ end
                                  "elixir_euler_rayleigh_taylor_instability.jl"),
                         l2=[
                             0.06365630515019809, 0.007166887172039836,
-                            0.0028787103533600804, 0.010247678008197966,
+                            0.0028787103533600804, 0.010247678008197966
                         ],
                         linf=[
                             0.47992143569849377, 0.02459548251933757,
-                            0.02059810091623976, 0.0319077000843877,
+                            0.02059810091623976, 0.0319077000843877
                         ],
                         cells_per_dimension=(8, 8),
                         tspan=(0.0, 0.3))
@@ -712,13 +712,13 @@ end
                             0.00019387402388722496,
                             0.03086514388623955,
                             0.04541427917165,
-                            43.892826583444716,
+                            43.892826583444716
                         ],
                         linf=[
                             0.0015942305974430138,
                             0.17449778969139373,
                             0.3729704262394843,
-                            307.6706958565337,
+                            307.6706958565337
                         ],
                         cells_per_dimension=(32, 16),
                         tspan=(0.0, 10.0))
@@ -736,11 +736,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_eulerpolytropic_convergence.jl"),
                         l2=[
                             0.00166898321776379, 0.00259202637930991,
-                            0.0032810744946276406,
+                            0.0032810744946276406
                         ],
                         linf=[
                             0.010994883201888683, 0.013309526619369905,
-                            0.020080326611175536,
+                            0.020080326611175536
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -760,11 +760,11 @@ end
                                      volume_integral = VolumeIntegralFluxDifferencing(volume_flux)),
                         l2=[
                             0.001668882059653298, 0.002592168188567654,
-                            0.0032809503514328307,
+                            0.0032809503514328307
                         ],
                         linf=[
                             0.01099467966437917, 0.013311978456333584,
-                            0.020080117011337606,
+                            0.020080117011337606
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -781,12 +781,12 @@ end
                         l2=[
                             0.03647890611450939,
                             0.025284915444045052,
-                            0.025340697771609126,
+                            0.025340697771609126
                         ],
                         linf=[
                             0.32516731565355583,
                             0.37509762516540046,
-                            0.29812843284727336,
+                            0.29812843284727336
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -803,11 +803,11 @@ end
                                  "elixir_eulerpolytropic_isothermal_wave.jl"),
                         l2=[
                             0.004998778512795407, 0.004998916021367992,
-                            8.991558055435833e-17,
+                            8.991558055435833e-17
                         ],
                         linf=[
                             0.010001103632831354, 0.010051165055185603,
-                            7.60697457718599e-16,
+                            7.60697457718599e-16
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -823,11 +823,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_eulerpolytropic_wave.jl"),
                         l2=[
                             0.23642871172548174, 0.2090519382039672,
-                            8.778842676292274e-17,
+                            8.778842676292274e-17
                         ],
                         linf=[
                             0.4852276879687425, 0.25327870807625175,
-                            5.533921691832115e-16,
+                            5.533921691832115e-16
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -861,12 +861,12 @@ end
                         l2=[
                             0.19357947606509474,
                             0.47041398037626814,
-                            0.4704139803762686,
+                            0.4704139803762686
                         ],
                         linf=[
                             0.35026352556630114,
                             0.8344372248051408,
-                            0.8344372248051408,
+                            0.8344372248051408
                         ],
                         tspan=(0.0, 0.1),
                         coverage_override=(polydeg = 3,)) # Prevent long compile time in CI
@@ -932,13 +932,13 @@ end
                             0.0017286908591070864,
                             0.025585037307655684,
                             0.028374244567802766,
-                            6.274146767730866e-5,
+                            6.274146767730866e-5
                         ],
                         linf=[
                             0.012973752001194772,
                             0.10829375385832263,
                             0.15832858475438094,
-                            0.00018196759554722775,
+                            0.00018196759554722775
                         ],
                         tspan=(0.0, 0.05))
     # Ensure that we do not have excessive memory allocations
@@ -957,13 +957,13 @@ end
                             0.7920927046419308,
                             9.92129670988898e-15,
                             1.0118635033124588e-14,
-                            0.7920927046419308,
+                            0.7920927046419308
                         ],
                         linf=[
                             2.408429868800133,
                             5.5835419986809516e-14,
                             5.448874313931364e-14,
-                            2.4084298688001335,
+                            2.4084298688001335
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations
@@ -1009,7 +1009,7 @@ end
                             0.03090169852186498, 0.030901698662039206,
                             0.04370160129981657, 8.259193829690747e-8,
                             0.03090169908364624, 0.030901699039770726,
-                            0.04370160128147445, 8.73592340076897e-9,
+                            0.04370160128147445, 8.73592340076897e-9
                         ],
                         linf=[
                             9.021023431587949e-7, 0.043701454182710486,
@@ -1020,7 +1020,7 @@ end
                             0.043701454182710764, 0.043701458294525895,
                             0.06180314632253597, 9.487023254761695e-7,
                             0.04370156101034084, 0.04370147392153745,
-                            0.06180318786081015, 3.430672973680963e-8,
+                            0.06180318786081015, 3.430672973680963e-8
                         ],
                         coverage_override=(maxiters = 10^5,))
 
@@ -1032,7 +1032,7 @@ end
             0.030901699039770684, 0.04370160128147447, 8.735923402748945e-9,
             1.0743426996067106e-7, 0.03090169852186498, 0.030901698662039206,
             0.04370160129981657, 8.259193829690747e-8, 0.03090169908364624,
-            0.030901699039770726, 0.04370160128147445, 8.73592340076897e-9,
+            0.030901699039770726, 0.04370160128147445, 8.73592340076897e-9
         ] rtol=1.0e-4
         @test errors.linf≈[
             9.021023431587949e-7, 0.043701454182710486, 0.043701458294527366,
@@ -1040,7 +1040,7 @@ end
             0.04370147392153734, 0.06180318786081025, 3.430673132525334e-8,
             9.02102342825728e-7, 0.043701454182710764, 0.043701458294525895,
             0.06180314632253597, 9.487023254761695e-7, 0.04370156101034084,
-            0.04370147392153745, 0.06180318786081015, 3.430672973680963e-8,
+            0.04370147392153745, 0.06180318786081015, 3.430672973680963e-8
         ] rtol=1.0e-4
         # Ensure that we do not have excessive memory allocations
         # (e.g., from type instabilities)
diff --git a/test/test_structured_3d.jl b/test/test_structured_3d.jl
index a52c459d6b..ac932b9535 100644
--- a/test/test_structured_3d.jl
+++ b/test/test_structured_3d.jl
@@ -84,14 +84,14 @@ end
                             0.009776048833895767,
                             0.00977604883389591,
                             0.009776048833895733,
-                            0.01506687097416608,
+                            0.01506687097416608
                         ],
                         linf=[
                             0.03285848350791731,
                             0.0321792316408982,
                             0.032179231640894645,
                             0.032179231640895534,
-                            0.0655408023333299,
+                            0.0655408023333299
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -110,14 +110,14 @@ end
                             9.361915278236651e-15,
                             9.95614203619935e-15,
                             1.6809941842374106e-14,
-                            1.4815037041566735e-14,
+                            1.4815037041566735e-14
                         ],
                         linf=[
                             4.1300296516055823e-14,
                             2.0444756998472258e-13,
                             1.0133560657266116e-13,
                             2.0627943797535409e-13,
-                            2.8954616482224083e-13,
+                            2.8954616482224083e-13
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -137,14 +137,14 @@ end
                             9.361915278236651e-15,
                             9.95614203619935e-15,
                             1.6809941842374106e-14,
-                            1.4815037041566735e-14,
+                            1.4815037041566735e-14
                         ],
                         linf=[
                             4.1300296516055823e-14,
                             2.0444756998472258e-13,
                             1.0133560657266116e-13,
                             2.0627943797535409e-13,
-                            2.8954616482224083e-13,
+                            2.8954616482224083e-13
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -164,14 +164,14 @@ end
                             0.003275679548217804,
                             0.0030020672748714084,
                             0.00324007343451744,
-                            0.005721986362580164,
+                            0.005721986362580164
                         ],
                         linf=[
                             0.03156756290660656,
                             0.033597629023726316,
                             0.02095783702361409,
                             0.03353574465232212,
-                            0.05873635745032857,
+                            0.05873635745032857
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -190,14 +190,14 @@ end
                             0.007022020327490176,
                             0.006759580335962235,
                             0.006820337637760632,
-                            0.02912659127566544,
+                            0.02912659127566544
                         ],
                         linf=[
                             0.2761764220925329,
                             0.20286331858055706,
                             0.18763944865434593,
                             0.19313636558790004,
-                            0.707563913727584,
+                            0.707563913727584
                         ],
                         tspan=(0.0, 0.25),
                         coverage_override=(polydeg = 3,)) # Prevent long compile time in CI
@@ -218,14 +218,14 @@ end
                             2.53167260e-02,
                             2.64276438e-02,
                             2.52195992e-02,
-                            3.56830295e-01,
+                            3.56830295e-01
                         ],
                         linf=[
                             6.16356950e-01,
                             2.50600049e-01,
                             2.74796377e-01,
                             2.46448217e-01,
-                            4.77888479e+00,
+                            4.77888479e+00
                         ],
                         tspan=(0.0, 0.3))
     # Ensure that we do not have excessive memory allocations
diff --git a/test/test_t8code_2d.jl b/test/test_t8code_2d.jl
index b63d2a105a..d950db743e 100644
--- a/test/test_t8code_2d.jl
+++ b/test/test_t8code_2d.jl
@@ -160,13 +160,13 @@ end
                             0.0034516244508588046,
                             0.0023420334036925493,
                             0.0024261923964557187,
-                            0.004731710454271893,
+                            0.004731710454271893
                         ],
                         linf=[
                             0.04155789011775046,
                             0.024772109862748914,
                             0.03759938693042297,
-                            0.08039824959535657,
+                            0.08039824959535657
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -185,7 +185,7 @@ end
                             2.063350241405049e-15,
                             1.8571016296925367e-14,
                             3.1769447886391905e-14,
-                            1.4104095258528071e-14,
+                            1.4104095258528071e-14
                         ],
                         linf=[1.9539925233402755e-14, 2e-12, 4.8e-12, 4e-12],
                         atol=2.0e-12,)
@@ -206,13 +206,13 @@ end
                             9.53984675e-02,
                             1.05633455e-01,
                             1.05636158e-01,
-                            3.50747237e-01,
+                            3.50747237e-01
                         ],
                         linf=[
                             2.94357464e-01,
                             4.07893014e-01,
                             3.97334516e-01,
-                            1.08142520e+00,
+                            1.08142520e+00
                         ],
                         tspan=(0.0, 1.0))
     # Ensure that we do not have excessive memory allocations
@@ -233,13 +233,13 @@ end
                             3.76149952e-01,
                             2.46970327e-01,
                             2.46970327e-01,
-                            1.28889042e+00,
+                            1.28889042e+00
                         ],
                         linf=[
                             1.22139001e+00,
                             1.17742626e+00,
                             1.17742626e+00,
-                            6.20638482e+00,
+                            6.20638482e+00
                         ],
                         tspan=(0.0, 0.3))
     # Ensure that we do not have excessive memory allocations
@@ -259,13 +259,13 @@ end
                             9.168126407325352e-5,
                             0.0009795410115453788,
                             0.002546408320320785,
-                            3.941189812642317e-6,
+                            3.941189812642317e-6
                         ],
                         linf=[
                             0.0009903782521019089,
                             0.0059752684687262025,
                             0.010941106525454103,
-                            1.2129488214718265e-5,
+                            1.2129488214718265e-5
                         ],
                         tspan=(0.0, 0.1))
     # Ensure that we do not have excessive memory allocations
diff --git a/test/test_t8code_3d.jl b/test/test_t8code_3d.jl
index 81d2a7cdd8..59bccddc05 100644
--- a/test/test_t8code_3d.jl
+++ b/test/test_t8code_3d.jl
@@ -119,14 +119,14 @@ mkdir(outdir)
                                 4.4993257426833716e-5,
                                 5.10588457841744e-5,
                                 5.102840924036687e-5,
-                                0.00019986264001630542,
+                                0.00019986264001630542
                             ],
                             linf=[
                                 0.0016987332417202072,
                                 0.003622956808262634,
                                 0.002029576258317789,
                                 0.0024206977281964193,
-                                0.008526972236273522,
+                                0.008526972236273522
                             ],
                             tspan=(0.0, 0.01))
         # Ensure that we do not have excessive memory allocations 
@@ -148,14 +148,14 @@ mkdir(outdir)
                                 0.0014733349038567685,
                                 0.00147333490385685,
                                 0.001473334903856929,
-                                0.0028149479453087093,
+                                0.0028149479453087093
                             ],
                             linf=[
                                 0.008070806335238156,
                                 0.009007245083113125,
                                 0.009007245083121784,
                                 0.009007245083102688,
-                                0.01562861968368434,
+                                0.01562861968368434
                             ],
                             tspan=(0.0, 1.0))
         # Ensure that we do not have excessive memory allocations 
@@ -176,14 +176,14 @@ mkdir(outdir)
                                 1.941857343642486e-14,
                                 2.0232366394187278e-14,
                                 2.3381518645408552e-14,
-                                7.083114561232324e-14,
+                                7.083114561232324e-14
                             ],
                             linf=[
                                 7.269740365245525e-13,
                                 3.289868377720495e-12,
                                 4.440087186807773e-12,
                                 3.8686831516088205e-12,
-                                9.412914891981927e-12,
+                                9.412914891981927e-12
                             ],
                             tspan=(0.0, 0.03))
         # Ensure that we do not have excessive memory allocations 
@@ -204,14 +204,14 @@ mkdir(outdir)
                                 4.889826056731442e-15,
                                 2.2921260987087585e-15,
                                 4.268460455702414e-15,
-                                1.1356712092620279e-14,
+                                1.1356712092620279e-14
                             ],
                             linf=[
                                 7.749356711883593e-14,
                                 2.8792246364872653e-13,
                                 1.1121659149182506e-13,
                                 3.3228975127030935e-13,
-                                9.592326932761353e-13,
+                                9.592326932761353e-13
                             ],
                             tspan=(0.0, 0.1), atol=5.0e-13,)
         # Ensure that we do not have excessive memory allocations 
@@ -232,14 +232,14 @@ mkdir(outdir)
                                 0.006192950051354618,
                                 0.005970674274073704,
                                 0.005965831290564327,
-                                0.02628875593094754,
+                                0.02628875593094754
                             ],
                             linf=[
                                 0.3326911600075694,
                                 0.2824952141320467,
                                 0.41401037398065543,
                                 0.45574161423218573,
-                                0.8099577682187109,
+                                0.8099577682187109
                             ],
                             tspan=(0.0, 0.2),
                             coverage_override=(polydeg = 3,)) # Prevent long compile time in CI
@@ -262,14 +262,14 @@ mkdir(outdir)
                                 4.33260474e-02,
                                 4.33260474e-02,
                                 4.33260474e-02,
-                                3.75260911e-01,
+                                3.75260911e-01
                             ],
                             linf=[
                                 7.45329845e-01,
                                 3.21754792e-01,
                                 3.21754792e-01,
                                 3.21754792e-01,
-                                4.76151527e+00,
+                                4.76151527e+00
                             ],
                             tspan=(0.0, 0.3),
                             coverage_override=(polydeg = 3,)) # Prevent long compile time in CI
diff --git a/test/test_threaded.jl b/test/test_threaded.jl
index 7365dcef21..f63cda87a5 100644
--- a/test/test_threaded.jl
+++ b/test/test_threaded.jl
@@ -92,13 +92,13 @@ Trixi.MPI.Barrier(Trixi.mpi_comm())
                                 2.259440511766445e-6,
                                 2.318888155713922e-6,
                                 2.3188881557894307e-6,
-                                6.3327863238858925e-6,
+                                6.3327863238858925e-6
                             ],
                             linf=[
                                 1.498738264560373e-5,
                                 1.9182011928187137e-5,
                                 1.918201192685487e-5,
-                                6.0526717141407005e-5,
+                                6.0526717141407005e-5
                             ],
                             rtol=0.001)
 
@@ -119,13 +119,13 @@ Trixi.MPI.Barrier(Trixi.mpi_comm())
                                 0.061751715597716854,
                                 0.05018223615408711,
                                 0.05018989446443463,
-                                0.225871559730513,
+                                0.225871559730513
                             ],
                             linf=[
                                 0.29347582879608825,
                                 0.31081249232844693,
                                 0.3107380389947736,
-                                1.0540358049885143,
+                                1.0540358049885143
                             ])
 
         # Ensure that we do not have excessive memory allocations
@@ -180,13 +180,13 @@ Trixi.MPI.Barrier(Trixi.mpi_comm())
                                 1.7088389997042244e-6,
                                 1.7437997855125774e-6,
                                 1.7437997855350776e-6,
-                                5.457223460127621e-6,
+                                5.457223460127621e-6
                             ],
                             linf=[
                                 9.796504903736292e-6,
                                 9.614745892783105e-6,
                                 9.614745892783105e-6,
-                                4.026107182575345e-5,
+                                4.026107182575345e-5
                             ],
                             tspan=(0.0, 0.1))
 
@@ -283,13 +283,13 @@ end
                                 0.0034516244508588046,
                                 0.0023420334036925493,
                                 0.0024261923964557187,
-                                0.004731710454271893,
+                                0.004731710454271893
                             ],
                             linf=[
                                 0.04155789011775046,
                                 0.024772109862748914,
                                 0.03759938693042297,
-                                0.08039824959535657,
+                                0.08039824959535657
                             ])
 
         # Ensure that we do not have excessive memory allocations
@@ -309,13 +309,13 @@ end
                                 0.00024871265138964204,
                                 0.0003370077102132591,
                                 0.0003370077102131964,
-                                0.0007231525513793697,
+                                0.0007231525513793697
                             ],
                             linf=[
                                 0.0015813032944647087,
                                 0.0020494288423820173,
                                 0.0020494288423824614,
-                                0.004793821195083758,
+                                0.004793821195083758
                             ],
                             tspan=(0.0, 0.1))
     end
@@ -329,13 +329,13 @@ end
                                 0.0034516244508588046,
                                 0.0023420334036925493,
                                 0.0024261923964557187,
-                                0.004731710454271893,
+                                0.004731710454271893
                             ],
                             linf=[
                                 0.04155789011775046,
                                 0.024772109862748914,
                                 0.03759938693042297,
-                                0.08039824959535657,
+                                0.08039824959535657
                             ])
     end
 
@@ -346,13 +346,13 @@ end
                                 0.00024871265138964204,
                                 0.0003370077102132591,
                                 0.0003370077102131964,
-                                0.0007231525513793697,
+                                0.0007231525513793697
                             ],
                             linf=[
                                 0.0015813032944647087,
                                 0.0020494288423820173,
                                 0.0020494288423824614,
-                                0.004793821195083758,
+                                0.004793821195083758
                             ],
                             tspan=(0.0, 0.1))
     end
@@ -370,13 +370,13 @@ end
                                 0.006400337855843578,
                                 0.005303799804137764,
                                 0.005303799804119745,
-                                0.013204169007030144,
+                                0.013204169007030144
                             ],
                             linf=[
                                 0.03798302318566282,
                                 0.05321027922532284,
                                 0.05321027922605448,
-                                0.13392025411839015,
+                                0.13392025411839015
                             ],)
 
         # Ensure that we do not have excessive memory allocations
@@ -397,13 +397,13 @@ end
                                 1.7204593127904542e-5,
                                 1.5921547179522804e-5,
                                 1.5921547180107928e-5,
-                                4.894071422525737e-5,
+                                4.894071422525737e-5
                             ],
                             linf=[
                                 0.00010525416930584619,
                                 0.00010003778091061122,
                                 0.00010003778085621029,
-                                0.00036426282101720275,
+                                0.00036426282101720275
                             ])
 
         # Ensure that we do not have excessive memory allocations
@@ -423,13 +423,13 @@ end
                                 2.344076909832665e-6,
                                 1.8610002398709756e-6,
                                 2.4095132179484066e-6,
-                                6.37330249340445e-6,
+                                6.37330249340445e-6
                             ],
                             linf=[
                                 2.509979394305084e-5,
                                 2.2683711321080935e-5,
                                 2.6180377720841363e-5,
-                                5.575278031910713e-5,
+                                5.575278031910713e-5
                             ])
 
         # Ensure that we do not have excessive memory allocations
@@ -449,13 +449,13 @@ end
                                 1.3333320340010056e-6,
                                 2.044834627970641e-6,
                                 2.044834627855601e-6,
-                                5.282189803559564e-6,
+                                5.282189803559564e-6
                             ],
                             linf=[
                                 2.7000151718858945e-6,
                                 3.988595028259212e-6,
                                 3.9885950273710336e-6,
-                                8.848583042286862e-6,
+                                8.848583042286862e-6
                             ])
 
         # Ensure that we do not have excessive memory allocations
diff --git a/test/test_tree_1d_euler.jl b/test/test_tree_1d_euler.jl
index 784d123128..528017499c 100644
--- a/test/test_tree_1d_euler.jl
+++ b/test/test_tree_1d_euler.jl
@@ -15,12 +15,12 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_1d_dgsem")
                         l2=[
                             2.2527950196212703e-8,
                             1.8187357193835156e-8,
-                            7.705669939973104e-8,
+                            7.705669939973104e-8
                         ],
                         linf=[
                             1.6205433861493646e-7,
                             1.465427772462391e-7,
-                            5.372255111879554e-7,
+                            5.372255111879554e-7
                         ],
                         # With the default `maxiters = 1` in coverage tests,
                         # there would be no time series to check against.
@@ -52,12 +52,12 @@ end
                         l2=[
                             0.019355699748523896,
                             0.022326984561234497,
-                            0.02523665947241734,
+                            0.02523665947241734
                         ],
                         linf=[
                             0.02895961127645519,
                             0.03293442484199227,
-                            0.04246098278632804,
+                            0.04246098278632804
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -74,12 +74,12 @@ end
                         l2=[
                             0.0011482554820217855,
                             0.00011482554830323462,
-                            5.741277429325267e-6,
+                            5.741277429325267e-6
                         ],
                         linf=[
                             0.004090978306812376,
                             0.0004090978313582294,
-                            2.045489210189544e-5,
+                            2.045489210189544e-5
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -96,12 +96,12 @@ end
                         l2=[
                             7.71293052584723e-16,
                             1.9712947511091717e-14,
-                            7.50672833504266e-15,
+                            7.50672833504266e-15
                         ],
                         linf=[
                             3.774758283725532e-15,
                             6.733502644351574e-14,
-                            2.4868995751603507e-14,
+                            2.4868995751603507e-14
                         ],
                         initial_condition=initial_condition_constant)
     # Ensure that we do not have excessive memory allocations
@@ -120,12 +120,12 @@ end
                         l2=[
                             3.8099996914101204e-6,
                             1.6745575717106341e-6,
-                            7.732189531480852e-6,
+                            7.732189531480852e-6
                         ],
                         linf=[
                             1.2971473393186272e-5,
                             9.270328934274374e-6,
-                            3.092514399671842e-5,
+                            3.092514399671842e-5
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -142,12 +142,12 @@ end
                         l2=[
                             0.11821957357197649,
                             0.15330089521538678,
-                            0.4417674632047301,
+                            0.4417674632047301
                         ],
                         linf=[
                             0.24280567569982958,
                             0.29130548795961936,
-                            0.8847009003152442,
+                            0.8847009003152442
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -164,12 +164,12 @@ end
                         l2=[
                             0.07803455838661963,
                             0.10032577312032283,
-                            0.29228156303827935,
+                            0.29228156303827935
                         ],
                         linf=[
                             0.2549869853794955,
                             0.3376472164661263,
-                            0.9650477546553962,
+                            0.9650477546553962
                         ],
                         maxiters=10,
                         surface_flux=flux_kennedy_gruber,
@@ -189,12 +189,12 @@ end
                         l2=[
                             0.07800654460172655,
                             0.10030365573277883,
-                            0.2921481199111959,
+                            0.2921481199111959
                         ],
                         linf=[
                             0.25408579350400395,
                             0.3388657679031271,
-                            0.9776486386921928,
+                            0.9776486386921928
                         ],
                         maxiters=10,
                         surface_flux=flux_shima_etal,
@@ -214,12 +214,12 @@ end
                         l2=[
                             0.07801923089205756,
                             0.10039557434912669,
-                            0.2922210399923278,
+                            0.2922210399923278
                         ],
                         linf=[
                             0.2576521982607225,
                             0.3409717926625057,
-                            0.9772961936567048,
+                            0.9772961936567048
                         ],
                         maxiters=10,
                         surface_flux=flux_chandrashekar,
@@ -240,7 +240,7 @@ end
                         linf=[
                             0.192621556068018,
                             0.25184744005299536,
-                            0.7264977555504792,
+                            0.7264977555504792
                         ],
                         maxiters=10,
                         surface_flux=flux_hll,
@@ -260,12 +260,12 @@ end
                         l2=[
                             0.11606096465319675,
                             0.15028768943458806,
-                            0.4328230323046703,
+                            0.4328230323046703
                         ],
                         linf=[
                             0.18031710091067965,
                             0.2351582421501841,
-                            0.6776805692092567,
+                            0.6776805692092567
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -283,7 +283,7 @@ end
                         linf=[
                             2.9766770877037168,
                             0.16838100902295852,
-                            2.6655773445485798,
+                            2.6655773445485798
                         ],
                         coverage_override=(maxiters = 6,))
     # Ensure that we do not have excessive memory allocations
@@ -319,7 +319,7 @@ end
                         linf=[
                             3.4296365168219216,
                             0.17635583964559245,
-                            2.6574584326179505,
+                            2.6574584326179505
                         ],
                         # Let this test run longer to cover some lines in flux_hllc
                         coverage_override=(maxiters = 10^5, tspan = (0.0, 0.1)))
@@ -339,7 +339,7 @@ end
                         linf=[
                             3.1773015255764427,
                             0.21331831536493773,
-                            2.6650170188241047,
+                            2.6650170188241047
                         ],
                         shock_indicator_variable=pressure,
                         cfl=0.2,
@@ -360,7 +360,7 @@ end
                         linf=[
                             3.1087017048015824,
                             0.17734706962928956,
-                            2.666689753470263,
+                            2.666689753470263
                         ],
                         shock_indicator_variable=density,
                         cfl=0.2,
@@ -396,7 +396,7 @@ end
                         linf=[
                             1.5180897390290355,
                             1.3967085956620369,
-                            2.0663825294019595,
+                            2.0663825294019595
                         ],
                         maxiters=30)
     # Ensure that we do not have excessive memory allocations
@@ -415,13 +415,13 @@ end
                             3.876288369618363e-7,
                             2.2247043122302947e-7,
                             2.964004224572679e-7,
-                            5.2716983399807875e-8,
+                            5.2716983399807875e-8
                         ],
                         linf=[
                             2.3925118561862746e-6,
                             1.3603693522767912e-6,
                             1.821888865105592e-6,
-                            1.1166012159335992e-7,
+                            1.1166012159335992e-7
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -440,13 +440,13 @@ end
                             0.045510421156346015,
                             0.036750584788912195,
                             0.2468985959132176,
-                            0.03684494180829024,
+                            0.03684494180829024
                         ],
                         linf=[
                             0.3313374853025697,
                             0.11621933362158643,
                             1.827403013568638,
-                            0.28045939999015723,
+                            0.28045939999015723
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -464,13 +464,13 @@ end
                             0.08889113985713998,
                             0.16199235348889673,
                             0.40316524365054346,
-                            2.9602775074723667e-16,
+                            2.9602775074723667e-16
                         ],
                         linf=[
                             0.28891355898284043,
                             0.3752709888964313,
                             0.84477102402413,
-                            8.881784197001252e-16,
+                            8.881784197001252e-16
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_tree_1d_eulergravity.jl b/test/test_tree_1d_eulergravity.jl
index 17bc0c71a7..70cc294812 100644
--- a/test/test_tree_1d_eulergravity.jl
+++ b/test/test_tree_1d_eulergravity.jl
@@ -14,11 +14,11 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_1d_dgsem")
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_eulergravity_convergence.jl"),
                         l2=[
                             0.00021708496949694728, 0.0002913795242132917,
-                            0.0006112500956552259,
+                            0.0006112500956552259
                         ],
                         linf=[
                             0.0004977733237385706, 0.0013594226727522418,
-                            0.0020418739554664,
+                            0.0020418739554664
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_tree_1d_eulermulti.jl b/test/test_tree_1d_eulermulti.jl
index b6c79ce03d..7f5b6d50c9 100644
--- a/test/test_tree_1d_eulermulti.jl
+++ b/test/test_tree_1d_eulermulti.jl
@@ -51,13 +51,13 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_1d_dgsem")
                                 0.1522380497572071,
                                 0.43830846465313206,
                                 0.03907262116499431,
-                                0.07814524232998862,
+                                0.07814524232998862
                             ],
                             linf=[
                                 0.24939193075537294,
                                 0.7139395740052739,
                                 0.06324208768391237,
-                                0.12648417536782475,
+                                0.12648417536782475
                             ])
         # Ensure that we do not have excessive memory allocations
         # (e.g., from type instabilities)
@@ -75,13 +75,13 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_1d_dgsem")
                                 8.575236038539227e-5,
                                 0.00016387804318585358,
                                 1.9412699303977585e-5,
-                                3.882539860795517e-5,
+                                3.882539860795517e-5
                             ],
                             linf=[
                                 0.00030593277277124464,
                                 0.0006244803933350696,
                                 7.253121435135679e-5,
-                                0.00014506242870271358,
+                                0.00014506242870271358
                             ])
         # Ensure that we do not have excessive memory allocations
         # (e.g., from type instabilities)
diff --git a/test/test_tree_1d_fdsbp.jl b/test/test_tree_1d_fdsbp.jl
index 33d67e3366..71e77eeb38 100644
--- a/test/test_tree_1d_fdsbp.jl
+++ b/test/test_tree_1d_fdsbp.jl
@@ -94,12 +94,12 @@ end
                             l2=[
                                 4.1370344463620254e-6,
                                 4.297052451817826e-6,
-                                9.857382045003056e-6,
+                                9.857382045003056e-6
                             ],
                             linf=[
                                 1.675305070092392e-5,
                                 1.3448113863834266e-5,
-                                3.8185336878271414e-5,
+                                3.8185336878271414e-5
                             ],
                             tspan=(0.0, 0.5))
 
@@ -118,12 +118,12 @@ end
                             l2=[
                                 3.413790589105506e-6,
                                 4.243957977156001e-6,
-                                8.667369423676437e-6,
+                                8.667369423676437e-6
                             ],
                             linf=[
                                 1.4228079689537765e-5,
                                 1.3249887941046978e-5,
-                                3.201552933251861e-5,
+                                3.201552933251861e-5
                             ],
                             tspan=(0.0, 0.5),
                             flux_splitting=splitting_vanleer_haenel)
@@ -143,12 +143,12 @@ end
                             l2=[
                                 8.6126767518378e-6,
                                 7.670897071480729e-6,
-                                1.4972772284191368e-5,
+                                1.4972772284191368e-5
                             ],
                             linf=[
                                 6.707982777909294e-5,
                                 3.487256699541419e-5,
-                                0.00010170331350556339,
+                                0.00010170331350556339
                             ],
                             tspan=(0.0, 0.5),
                             solver=DG(D_upw.central, nothing, SurfaceIntegralStrongForm(),
@@ -169,12 +169,12 @@ end
                             l2=[
                                 1.5894925236031034e-5,
                                 9.428412101106044e-6,
-                                0.0008986477358789918,
+                                0.0008986477358789918
                             ],
                             linf=[
                                 4.969438024382544e-5,
                                 2.393091812063694e-5,
-                                0.003271817388146303,
+                                0.003271817388146303
                             ],
                             tspan=(0.0, 0.005), abstol=1.0e-9, reltol=1.0e-9)
 
diff --git a/test/test_tree_1d_linearizedeuler.jl b/test/test_tree_1d_linearizedeuler.jl
index c7cffee3f6..210ad8645d 100644
--- a/test/test_tree_1d_linearizedeuler.jl
+++ b/test/test_tree_1d_linearizedeuler.jl
@@ -14,12 +14,12 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_1d_dgsem")
                         l2=[
                             0.00010894927270421941,
                             0.00014295255695912358,
-                            0.00010894927270421941,
+                            0.00010894927270421941
                         ],
                         linf=[
                             0.0005154647164193893,
                             0.00048457837684242266,
-                            0.0005154647164193893,
+                            0.0005154647164193893
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -37,7 +37,7 @@ end
                         linf=[
                             1.9999505145390108,
                             0.9999720404625275,
-                            1.9999505145390108,
+                            1.9999505145390108
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_tree_1d_mhd.jl b/test/test_tree_1d_mhd.jl
index 2150ddfd07..e27a075b09 100644
--- a/test/test_tree_1d_mhd.jl
+++ b/test/test_tree_1d_mhd.jl
@@ -20,7 +20,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_1d_dgsem")
                             3.9938347410210535e-14,
                             3.984545392098788e-16,
                             2.4782402104201577e-15,
-                            1.551737464879987e-15,
+                            1.551737464879987e-15
                         ],
                         linf=[
                             1.9984014443252818e-15,
@@ -30,7 +30,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_1d_dgsem")
                             7.815970093361102e-14,
                             8.881784197001252e-16,
                             2.886579864025407e-15,
-                            2.942091015256665e-15,
+                            2.942091015256665e-15
                         ],
                         initial_condition=initial_condition_constant,
                         tspan=(0.0, 1.0))
@@ -54,7 +54,7 @@ end
                             5.084863194951084e-6,
                             1.1963224165731992e-16,
                             3.598916927583752e-5,
-                            3.598916927594727e-5,
+                            3.598916927594727e-5
                         ],
                         linf=[
                             2.614095879338585e-5,
@@ -64,7 +64,7 @@ end
                             1.5066209528846741e-5,
                             2.220446049250313e-16,
                             0.00012658678753942054,
-                            0.00012658678753908748,
+                            0.00012658678753908748
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -86,7 +86,7 @@ end
                             1.967962220860377e-6,
                             1.1963224165731992e-16,
                             3.583562899483433e-5,
-                            3.583562899486565e-5,
+                            3.583562899486565e-5
                         ],
                         linf=[
                             5.830577969345718e-5,
@@ -96,7 +96,7 @@ end
                             6.978806516122482e-6,
                             2.220446049250313e-16,
                             0.00012564003648959932,
-                            0.00012564003648994626,
+                            0.00012564003648994626
                         ],
                         volume_flux=flux_derigs_etal)
     # Ensure that we do not have excessive memory allocations
@@ -115,13 +115,13 @@ end
                             1.036850596986597e-5, 1.965192583650368e-6,
                             3.5882124656715505e-5, 3.5882124656638764e-5,
                             5.270975504780837e-6, 1.1963224165731992e-16,
-                            3.595811808912869e-5, 3.5958118089159453e-5,
+                            3.595811808912869e-5, 3.5958118089159453e-5
                         ],
                         linf=[
                             2.887280521446378e-5, 7.310580790352001e-6,
                             0.00012390046377899755, 0.00012390046377787345,
                             1.5102711136583125e-5, 2.220446049250313e-16,
-                            0.0001261935452181312, 0.0001261935452182006,
+                            0.0001261935452181312, 0.0001261935452182006
                         ],
                         surface_flux=flux_hllc)
     # Ensure that we do not have excessive memory allocations
@@ -144,7 +144,7 @@ end
                             0.15578125987042743,
                             4.130462730494e-17,
                             0.05465258887150046,
-                            0.05465258887150046,
+                            0.05465258887150046
                         ],
                         linf=[
                             0.12165312668363826,
@@ -154,7 +154,7 @@ end
                             0.44079257431070706,
                             1.1102230246251565e-16,
                             0.10528911365809579,
-                            0.10528911365809579,
+                            0.10528911365809579
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -176,7 +176,7 @@ end
                             0.3723215736814466,
                             1.2060075775846403e-15,
                             0.36276754492568164,
-                            0.0,
+                            0.0
                         ],
                         linf=[
                             0.5797109945880677,
@@ -186,7 +186,7 @@ end
                             1.0526758874956808,
                             5.995204332975845e-15,
                             1.5122922036932964,
-                            0.0,
+                            0.0
                         ],
                         coverage_override=(maxiters = 6,))
     # Ensure that we do not have excessive memory allocations
@@ -209,7 +209,7 @@ end
                             0.9204708961093411,
                             1.3216517820475193e-16,
                             0.28897419402047725,
-                            0.25521206483145126,
+                            0.25521206483145126
                         ],
                         linf=[
                             1.2185238171352286,
@@ -219,7 +219,7 @@ end
                             1.660723397705417,
                             2.220446049250313e-16,
                             0.6874726847741993,
-                            0.65536978110274,
+                            0.65536978110274
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -238,13 +238,13 @@ end
                             0.4573799618744708, 0.4792633358230866, 0.34064852506872795,
                             0.4479668434955162, 0.9203891782415092,
                             1.3216517820475193e-16, 0.28887826520860815,
-                            0.255281629265771,
+                            0.255281629265771
                         ],
                         linf=[
                             1.2382842201671505, 0.8929169308132259, 0.871298623806198,
                             0.9822415614542821, 1.6726170732132717,
                             2.220446049250313e-16, 0.7016155888023747,
-                            0.6556091522071984,
+                            0.6556091522071984
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -266,7 +266,7 @@ end
                             0.9606363432904367,
                             6.608258910237605e-17,
                             0.21542929107153735,
-                            0.10705457908737925,
+                            0.10705457908737925
                         ],
                         linf=[
                             0.6447951791685409,
@@ -276,7 +276,7 @@ end
                             2.0770652030507053,
                             1.1102230246251565e-16,
                             0.49670855513788204,
-                            0.24830199967863564,
+                            0.24830199967863564
                         ],
                         tspan=(0.0, 0.1))
     # Ensure that we do not have excessive memory allocations
@@ -299,7 +299,7 @@ end
                             5.21930435e+01,
                             6.56538824e-16,
                             1.01022340e+00,
-                            0.00000000e+00,
+                            0.00000000e+00
                         ],
                         linf=[
                             2.87172004e+00,
@@ -309,7 +309,7 @@ end
                             1.35152372e+02,
                             3.44169138e-15,
                             2.83556069e+00,
-                            0.00000000e+00,
+                            0.00000000e+00
                         ],
                         tspan=(0.0, 0.2),
                         coverage_override=(maxiters = 6,))
@@ -336,7 +336,7 @@ end
                             5.23565514e+01,
                             3.18641825e-16,
                             1.00485291e+00,
-                            0.00000000e+00,
+                            0.00000000e+00
                         ],
                         linf=[
                             2.92876280e+00,
@@ -346,7 +346,7 @@ end
                             1.36966213e+02,
                             1.55431223e-15,
                             2.80548864e+00,
-                            0.00000000e+00,
+                            0.00000000e+00
                         ],
                         initial_condition=initial_condition_shu_osher_shock_tube_flipped,
                         boundary_conditions=BoundaryConditionDirichlet(initial_condition_shu_osher_shock_tube_flipped),
diff --git a/test/test_tree_1d_shallowwater.jl b/test/test_tree_1d_shallowwater.jl
index 8fe3291a93..ad7a77a1ed 100644
--- a/test/test_tree_1d_shallowwater.jl
+++ b/test/test_tree_1d_shallowwater.jl
@@ -15,12 +15,12 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_1d_dgsem")
                         l2=[
                             0.24476140682560343,
                             0.8587309324660326,
-                            0.07330427577586297,
+                            0.07330427577586297
                         ],
                         linf=[
                             2.1636963952308372,
                             3.8737770522883115,
-                            1.7711213427919539,
+                            1.7711213427919539
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations
@@ -38,12 +38,12 @@ end
                         l2=[
                             0.39472828074570576,
                             2.0390687947320076,
-                            4.1623084150546725e-10,
+                            4.1623084150546725e-10
                         ],
                         linf=[
                             0.7793741954662221,
                             3.2411927977882096,
-                            7.419800190922032e-10,
+                            7.419800190922032e-10
                         ],
                         initial_condition=initial_condition_weak_blast_wave,
                         tspan=(0.0, 0.25))
@@ -62,7 +62,7 @@ end
                         l2=[
                             0.10416666834254829,
                             1.4352935256803184e-14,
-                            0.10416666834254838,
+                            0.10416666834254838
                         ],
                         linf=[1.9999999999999996, 3.248036646353028e-14, 2.0],
                         tspan=(0.0, 0.25))
@@ -81,7 +81,7 @@ end
                         l2=[
                             0.10416666834254835,
                             1.1891029971551825e-14,
-                            0.10416666834254838,
+                            0.10416666834254838
                         ],
                         linf=[2.0000000000000018, 2.4019608337954543e-14, 2.0],
                         surface_flux=(FluxHydrostaticReconstruction(flux_lax_friedrichs,
@@ -103,7 +103,7 @@ end
                         l2=[
                             0.10416666834254838,
                             1.6657566141935285e-14,
-                            0.10416666834254838,
+                            0.10416666834254838
                         ],
                         linf=[2.0000000000000004, 3.0610625110157164e-14, 2.0],
                         surface_flux=(flux_wintermeyer_etal,
@@ -126,12 +126,12 @@ end
                         l2=[
                             0.0022363707373868713,
                             0.01576799981934617,
-                            4.436491725585346e-5,
+                            4.436491725585346e-5
                         ],
                         linf=[
                             0.00893601803417754,
                             0.05939797350246456,
-                            9.098379777405796e-5,
+                            9.098379777405796e-5
                         ],
                         tspan=(0.0, 0.025))
     # Ensure that we do not have excessive memory allocations
@@ -149,12 +149,12 @@ end
                         l2=[
                             0.002275023323848826,
                             0.015861093821754046,
-                            4.436491725585346e-5,
+                            4.436491725585346e-5
                         ],
                         linf=[
                             0.008461451098266792,
                             0.05722331401673486,
-                            9.098379777405796e-5,
+                            9.098379777405796e-5
                         ],
                         tspan=(0.0, 0.025),
                         surface_flux=(flux_hll,
@@ -174,12 +174,12 @@ end
                         l2=[
                             0.005774284062933275,
                             0.017408601639513584,
-                            4.43649172561843e-5,
+                            4.43649172561843e-5
                         ],
                         linf=[
                             0.01639116193303547,
                             0.05102877460799604,
-                            9.098379777450205e-5,
+                            9.098379777450205e-5
                         ],
                         surface_flux=(flux_wintermeyer_etal,
                                       flux_nonconservative_ersing_etal),
@@ -202,12 +202,12 @@ end
                         l2=[
                             0.0022851099219788917,
                             0.01560453773635554,
-                            4.43649172558535e-5,
+                            4.43649172558535e-5
                         ],
                         linf=[
                             0.008934615705174398,
                             0.059403169140869405,
-                            9.098379777405796e-5,
+                            9.098379777405796e-5
                         ],
                         tspan=(0.0, 0.025))
     # Ensure that we do not have excessive memory allocations
@@ -226,12 +226,12 @@ end
                         l2=[
                             0.0022956052733432287,
                             0.015540053559855601,
-                            4.43649172558535e-5,
+                            4.43649172558535e-5
                         ],
                         linf=[
                             0.008460440313118323,
                             0.05720939349382359,
-                            9.098379777405796e-5,
+                            9.098379777405796e-5
                         ],
                         surface_flux=(FluxHydrostaticReconstruction(FluxHLL(min_max_speed_naive),
                                                                     hydrostatic_reconstruction_audusse_etal),
@@ -253,12 +253,12 @@ end
                         l2=[
                             1.725964362045055e-8,
                             5.0427180314307505e-16,
-                            1.7259643530442137e-8,
+                            1.7259643530442137e-8
                         ],
                         linf=[
                             3.844551077492042e-8,
                             3.469453422316143e-15,
-                            3.844551077492042e-8,
+                            3.844551077492042e-8
                         ],
                         tspan=(0.0, 0.25),
                         surface_flux=(FluxHLL(min_max_speed_naive),
@@ -279,12 +279,12 @@ end
                         l2=[
                             1.7259643614361866e-8,
                             3.5519018243195145e-16,
-                            1.7259643530442137e-8,
+                            1.7259643530442137e-8
                         ],
                         linf=[
                             3.844551010878661e-8,
                             9.846474508971374e-16,
-                            3.844551077492042e-8,
+                            3.844551077492042e-8
                         ],
                         tspan=(0.0, 0.25),
                         surface_flux=(FluxHLL(min_max_speed_naive),
@@ -307,7 +307,7 @@ end
                         linf=[
                             1.1209754279344226,
                             1.3230788645853582,
-                            0.8646939843534251,
+                            0.8646939843534251
                         ],
                         tspan=(0.0, 0.05))
     # Ensure that we do not have excessive memory allocations
@@ -327,13 +327,13 @@ end
                             6.37048760275098e-5,
                             0.0002745658116815704,
                             4.436491725647962e-6,
-                            8.872983451152218e-6,
+                            8.872983451152218e-6
                         ],
                         linf=[
                             0.00026747526881631956,
                             0.0012106730729152249,
                             9.098379777500165e-6,
-                            1.8196759554278685e-5,
+                            1.8196759554278685e-5
                         ],
                         tspan=(0.0, 0.05))
     # Ensure that we do not have excessive memory allocations
@@ -353,13 +353,13 @@ end
                             1.4250229186905198e-14,
                             2.495109919406496e-12,
                             7.408599286788738e-17,
-                            2.7205812409138776e-16,
+                            2.7205812409138776e-16
                         ],
                         linf=[
                             5.284661597215745e-14,
                             2.74056233065078e-12,
                             2.220446049250313e-16,
-                            8.881784197001252e-16,
+                            8.881784197001252e-16
                         ],
                         tspan=(0.0, 100.0))
     # Ensure that we do not have excessive memory allocations
@@ -379,13 +379,13 @@ end
                             0.02843233740533314,
                             0.14083324483705398,
                             0.0054554472558998,
-                            0.005455447255899814,
+                            0.005455447255899814
                         ],
                         linf=[
                             0.26095842440037487,
                             0.45919004549253795,
                             0.09999999999999983,
-                            0.10000000000000009,
+                            0.10000000000000009
                         ],)
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_tree_2d_acoustics.jl b/test/test_tree_2d_acoustics.jl
index 89bccbf8ca..070eca8772 100644
--- a/test/test_tree_2d_acoustics.jl
+++ b/test/test_tree_2d_acoustics.jl
@@ -19,7 +19,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                             0.0,
                             0.0,
                             0.0,
-                            0.0,
+                            0.0
                         ],
                         linf=[
                             0.00769282588065634,
@@ -28,7 +28,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                             0.0,
                             0.0,
                             0.0,
-                            0.0,
+                            0.0
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -49,7 +49,7 @@ end
                             0.0,
                             0.0,
                             0.0,
-                            0.0,
+                            0.0
                         ],
                         linf=[
                             0.17261097190220992,
@@ -58,7 +58,7 @@ end
                             0.0,
                             0.0,
                             0.0,
-                            0.0,
+                            0.0
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -79,7 +79,7 @@ end
                             0.0,
                             0.0,
                             0.0,
-                            0.0,
+                            0.0
                         ],
                         linf=[
                             0.03970270697049378,
@@ -88,7 +88,7 @@ end
                             0.0,
                             0.0,
                             0.0,
-                            0.0,
+                            0.0
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_tree_2d_euler.jl b/test/test_tree_2d_euler.jl
index a004d1452b..9e0b970a5f 100644
--- a/test/test_tree_2d_euler.jl
+++ b/test/test_tree_2d_euler.jl
@@ -16,13 +16,13 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                             9.321181253186009e-7,
                             1.4181210743438511e-6,
                             1.4181210743487851e-6,
-                            4.824553091276693e-6,
+                            4.824553091276693e-6
                         ],
                         linf=[
                             9.577246529612893e-6,
                             1.1707525976012434e-5,
                             1.1707525976456523e-5,
-                            4.8869615580926506e-5,
+                            4.8869615580926506e-5
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -40,13 +40,13 @@ end
                             0.026440292358506527,
                             0.013245905852168414,
                             0.013245905852168479,
-                            0.03912520302609374,
+                            0.03912520302609374
                         ],
                         linf=[
                             0.042130817806361964,
                             0.022685499230187034,
                             0.022685499230187922,
-                            0.06999771202145322,
+                            0.06999771202145322
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -64,13 +64,13 @@ end
                             0.0010600778457964775,
                             0.00010600778457634275,
                             0.00021201556915872665,
-                            2.650194614399671e-5,
+                            2.650194614399671e-5
                         ],
                         linf=[
                             0.006614198043413566,
                             0.0006614198043973507,
                             0.001322839608837334,
-                            0.000165354951256802,
+                            0.000165354951256802
                         ],
                         tspan=(0.0, 0.5))
     # Ensure that we do not have excessive memory allocations
@@ -90,13 +90,13 @@ end
                             2.259440511766445e-6,
                             2.318888155713922e-6,
                             2.3188881557894307e-6,
-                            6.3327863238858925e-6,
+                            6.3327863238858925e-6
                         ],
                         linf=[
                             1.498738264560373e-5,
                             1.9182011928187137e-5,
                             1.918201192685487e-5,
-                            6.0526717141407005e-5,
+                            6.0526717141407005e-5
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -114,13 +114,13 @@ end
                             0.061751715597716854,
                             0.05018223615408711,
                             0.05018989446443463,
-                            0.225871559730513,
+                            0.225871559730513
                         ],
                         linf=[
                             0.29347582879608825,
                             0.31081249232844693,
                             0.3107380389947736,
-                            1.0540358049885143,
+                            1.0540358049885143
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -138,13 +138,13 @@ end
                             0.03481471610306124,
                             0.027694280613944234,
                             0.027697905866996532,
-                            0.12932052501462554,
+                            0.12932052501462554
                         ],
                         linf=[
                             0.31052098400669004,
                             0.3481295959664616,
                             0.34807152194137336,
-                            1.1044947556170719,
+                            1.1044947556170719
                         ],
                         maxiters=10,
                         surface_flux=flux_kennedy_gruber,
@@ -165,13 +165,13 @@ end
                             0.03481122603050542,
                             0.027662840593087695,
                             0.027665658732350273,
-                            0.12927455860656786,
+                            0.12927455860656786
                         ],
                         linf=[
                             0.3110089578739834,
                             0.34888111987218107,
                             0.3488278669826813,
-                            1.1056349046774305,
+                            1.1056349046774305
                         ],
                         maxiters=10,
                         surface_flux=flux_chandrashekar,
@@ -192,13 +192,13 @@ end
                             0.05380629130119074,
                             0.04696798008325309,
                             0.04697067787841479,
-                            0.19687382235494968,
+                            0.19687382235494968
                         ],
                         linf=[
                             0.18527440131928286,
                             0.2404798030563736,
                             0.23269573860381076,
-                            0.6874012187446894,
+                            0.6874012187446894
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -217,13 +217,13 @@ end
                             0.08508152653623638,
                             0.04510301725066843,
                             0.04510304668512745,
-                            0.6930705064715306,
+                            0.6930705064715306
                         ],
                         linf=[
                             0.31136518019691406,
                             0.5617651935473419,
                             0.5621200790240503,
-                            2.8866869108596056,
+                            2.8866869108596056
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -249,13 +249,13 @@ end
                             0.05624855363458103,
                             0.06931288786158463,
                             0.06931283188960778,
-                            0.6200535829842072,
+                            0.6200535829842072
                         ],
                         linf=[
                             0.29029967648805566,
                             0.6494728865862608,
                             0.6494729363533714,
-                            3.0949621505674787,
+                            3.0949621505674787
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -273,13 +273,13 @@ end
                             0.14170569763947993,
                             0.11647068900798814,
                             0.11647072556898294,
-                            0.3391989213659599,
+                            0.3391989213659599
                         ],
                         linf=[
                             1.6544204510794196,
                             1.35194638484646,
                             1.3519463848472744,
-                            1.831228461662809,
+                            1.831228461662809
                         ],
                         maxiters=30)
     # Ensure that we do not have excessive memory allocations
@@ -298,13 +298,13 @@ end
                             0.39957047631960346,
                             0.21006912294983154,
                             0.21006903549932,
-                            0.6280328163981136,
+                            0.6280328163981136
                         ],
                         linf=[
                             2.20417889887697,
                             1.5487238480003327,
                             1.5486788679247812,
-                            2.4656795949035857,
+                            2.4656795949035857
                         ],
                         tspan=(0.0, 0.5),
                         # Let this test run longer to cover some lines in flux_hllc
@@ -325,13 +325,13 @@ end
                             0.6835576416907511,
                             0.2839963955262972,
                             0.28399565983676,
-                            0.7229447806293277,
+                            0.7229447806293277
                         ],
                         linf=[
                             3.0969614882801393,
                             1.7967947300740248,
                             1.7967508302506658,
-                            3.040149575567518,
+                            3.040149575567518
                         ],
                         tspan=(0.0, 1.0),
                         coverage_override=(maxiters = 6,))
@@ -352,13 +352,13 @@ end
                             0.3221177942225801,
                             0.1798478357478982,
                             0.1798364616438908,
-                            0.6136884131056267,
+                            0.6136884131056267
                         ],
                         linf=[
                             1.343766644801395,
                             1.1749593109683463,
                             1.1747613085307178,
-                            2.4216006041018785,
+                            2.4216006041018785
                         ],
                         tspan=(0.0, 0.5),
                         initial_refinement_level=4,
@@ -379,13 +379,13 @@ end
                             0.4866953770742574,
                             0.1673477470091984,
                             0.16734774700934,
-                            0.6184367248923149,
+                            0.6184367248923149
                         ],
                         linf=[
                             2.6724832723962053,
                             1.2916089288910635,
                             1.2916089289001427,
-                            6.474699399394252,
+                            6.474699399394252
                         ],
                         tspan=(0.0, 1.0),
                         coverage_override=(maxiters = 6,))
@@ -407,13 +407,13 @@ end
                             0.41444427153173785,
                             0.1460669409661223,
                             0.14606693069201596,
-                            0.6168046457461059,
+                            0.6168046457461059
                         ],
                         linf=[
                             1.5720584643579567,
                             0.7946656826861964,
                             0.7946656525739751,
-                            6.455520291414711,
+                            6.455520291414711
                         ],
                         tspan=(0.0, 1.0),
                         initial_refinement_level=4,
@@ -447,13 +447,13 @@ end
                             0.352405949321075,
                             0.17207721487429464,
                             0.17207721487433883,
-                            0.6263024434020885,
+                            0.6263024434020885
                         ],
                         linf=[
                             2.760997358628186,
                             1.8279186132509326,
                             1.8279186132502805,
-                            6.251573757093399,
+                            6.251573757093399
                         ],
                         tspan=(0.0, 0.5),
                         callbacks=CallbackSet(summary_callback,
@@ -476,13 +476,13 @@ end
                             0.48862067511841695,
                             0.16787541578869494,
                             0.16787541578869422,
-                            0.6184319933114926,
+                            0.6184319933114926
                         ],
                         linf=[
                             2.6766520821013002,
                             1.2910938760258996,
                             1.2910938760258899,
-                            6.473385481404865,
+                            6.473385481404865
                         ],
                         tspan=(0.0, 1.0),
                         coverage_override=(maxiters = 3,))
@@ -502,13 +502,13 @@ end
                             0.22271619518391986,
                             0.6284824759323494,
                             0.24864213447943648,
-                            2.9591811489995474,
+                            2.9591811489995474
                         ],
                         linf=[
                             9.15245400430106,
                             24.96562810334389,
                             10.388109127032374,
-                            101.20581544156934,
+                            101.20581544156934
                         ],
                         tspan=(0.0, 0.5))
     # Ensure that we do not have excessive memory allocations
@@ -527,13 +527,13 @@ end
                             0.2086261501910662,
                             1.2118352377894666,
                             0.10255333189606497,
-                            5.296238138639236,
+                            5.296238138639236
                         ],
                         linf=[
                             14.829071984498198,
                             74.12967742435727,
                             6.863554388300223,
-                            303.58813147491134,
+                            303.58813147491134
                         ],
                         tspan=(0.0, 0.12),
                         # Let this test run longer to cover the ControllerThreeLevelCombined lines
@@ -555,13 +555,13 @@ end
                             0.1057230211245312,
                             0.10621112311257341,
                             0.07260957505339989,
-                            0.11178239111065721,
+                            0.11178239111065721
                         ],
                         linf=[
                             2.998719417992662,
                             2.1400285015556166,
                             1.1569648700415078,
-                            1.8922492268110913,
+                            1.8922492268110913
                         ],
                         tspan=(0.0, 0.1))
     # Ensure that we do not have excessive memory allocations
@@ -581,13 +581,13 @@ end
                             0.055691508271624536,
                             0.032986009333751655,
                             0.05224390923711999,
-                            0.08009536362771563,
+                            0.08009536362771563
                         ],
                         linf=[
                             0.24043622527087494,
                             0.1660878796929941,
                             0.12355946691711608,
-                            0.2694290787257758,
+                            0.2694290787257758
                         ],
                         tspan=(0.0, 0.2))
     # Ensure that we do not have excessive memory allocations
@@ -607,13 +607,13 @@ end
                             0.05569452733654995,
                             0.033107109983417926,
                             0.05223609622852158,
-                            0.08007777597488817,
+                            0.08007777597488817
                         ],
                         linf=[
                             0.2535807803900303,
                             0.17397028249895308,
                             0.12321616095649354,
-                            0.269046666668995,
+                            0.269046666668995
                         ],
                         tspan=(0.0, 0.2),
                         coverage_override=(maxiters = 2,))
@@ -635,13 +635,13 @@ end
                             0.42185634563805724,
                             0.1686471269704017,
                             0.18240674916968103,
-                            0.17858250604280654,
+                            0.17858250604280654
                         ],
                         linf=[
                             1.7012978064377158,
                             0.7149714986746726,
                             0.5822547982757897,
-                            0.7300051017382696,
+                            0.7300051017382696
                         ],
                         tspan=(0.0, 2.0),
                         coverage_override=(maxiters = 7,),
@@ -666,13 +666,13 @@ end
                             0.007237139090503349,
                             0.044887582765386916,
                             1.0453570959003603e-6,
-                            0.6627307840935432,
+                            0.6627307840935432
                         ],
                         linf=[
                             0.19437260992446315,
                             0.5554343646648533,
                             5.943891455255412e-5,
-                            15.188919846360125,
+                            15.188919846360125
                         ],
                         tspan=(0.0, 0.1))
     # Ensure that we do not have excessive memory allocations
@@ -691,13 +691,13 @@ end
                             0.006768801432802192,
                             0.032184992228603666,
                             6.923887797276484e-7,
-                            0.6784222932398366,
+                            0.6784222932398366
                         ],
                         linf=[
                             0.2508663007713608,
                             0.4097017076529792,
                             0.0003528986458217968,
-                            22.435474993016918,
+                            22.435474993016918
                         ],
                         tspan=(0.0, 0.1),
                         coverage_override=(maxiters = 2,))
@@ -717,13 +717,13 @@ end
                             0.011338365293662804,
                             10.09743543555765,
                             0.00392429463200361,
-                            4031.7811487690506,
+                            4031.7811487690506
                         ],
                         linf=[
                             3.3178633141984193,
                             2993.6445033486402,
                             8.031723414357423,
-                            1.1918867260293828e6,
+                            1.1918867260293828e6
                         ],
                         tspan=(0.0, 1.0e-7),
                         coverage_override=(maxiters = 6,))
@@ -743,13 +743,13 @@ end
                             0.00013492249515826863,
                             0.006615696236378061,
                             0.006782108219800376,
-                            0.016393831451740604,
+                            0.016393831451740604
                         ],
                         linf=[
                             0.0020782600954247776,
                             0.08150078921935999,
                             0.08663621974991986,
-                            0.2829930622010579,
+                            0.2829930622010579
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -768,13 +768,13 @@ end
                             0.0017208369388227673,
                             0.09628684992237334,
                             0.09620157717330868,
-                            0.1758809552387432,
+                            0.1758809552387432
                         ],
                         linf=[
                             0.021869936355319086,
                             0.9956698009442038,
                             1.0002507727219028,
-                            2.223249697515648,
+                            2.223249697515648
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -792,13 +792,13 @@ end
                             0.0017203323613648241,
                             0.09628962878682261,
                             0.09621241164155782,
-                            0.17585995600340926,
+                            0.17585995600340926
                         ],
                         linf=[
                             0.021740570456931674,
                             0.9938841665880938,
                             1.004140123355135,
-                            2.224108857746245,
+                            2.224108857746245
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -816,13 +816,13 @@ end
                             0.0017158367642679273,
                             0.09619888722871434,
                             0.09616432767924141,
-                            0.17553381166255197,
+                            0.17553381166255197
                         ],
                         linf=[
                             0.021853862449723982,
                             0.9878047229255944,
                             0.9880191167111795,
-                            2.2154030488035588,
+                            2.2154030488035588
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -841,13 +841,13 @@ end
                             0.0017203324051381415,
                             0.09628962899999398,
                             0.0962124115572114,
-                            0.1758599596626405,
+                            0.1758599596626405
                         ],
                         linf=[
                             0.021740568112562086,
                             0.9938841624655501,
                             1.0041401179009877,
-                            2.2241087041100798,
+                            2.2241087041100798
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -866,13 +866,13 @@ end
                             5.051719943432265e-5,
                             0.0022574259317084747,
                             0.0021755998463189713,
-                            0.004346492398617521,
+                            0.004346492398617521
                         ],
                         linf=[
                             0.0012880114865917447,
                             0.03857193149447702,
                             0.031090457959835893,
-                            0.12125130332971423,
+                            0.12125130332971423
                         ],
                         # Let this test run longer to cover some lines in the AMR indicator
                         coverage_override=(maxiters = 10^5, tspan = (0.0, 10.5)))
@@ -892,13 +892,13 @@ end
                             0.03341239373099515,
                             0.026673245711492915,
                             0.026678871434568822,
-                            0.12397486476145089,
+                            0.12397486476145089
                         ],
                         linf=[
                             0.3290981764688339,
                             0.3812055782309788,
                             0.3812041851225023,
-                            1.168251216556933,
+                            1.168251216556933
                         ],
                         periodicity=false,
                         boundary_conditions=boundary_condition_slip_wall,
@@ -919,13 +919,13 @@ end
                             0.0001379946769624388,
                             0.02078779689715382,
                             0.033237241571263176,
-                            31.36068872331705,
+                            31.36068872331705
                         ],
                         linf=[
                             0.0016286690573188434,
                             0.15623770697198225,
                             0.3341371832270615,
-                            334.5373488726036,
+                            334.5373488726036
                         ],
                         tspan=(0.0, 10.0),
                         initial_refinement_level=4)
@@ -947,13 +947,13 @@ end
                                 1.1790213022362371e-16,
                                 8.580657423476384e-17,
                                 1.3082387431804115e-16,
-                                1.6182739965672862e-15,
+                                1.6182739965672862e-15
                             ],
                             linf=[
                                 3.3306690738754696e-16,
                                 2.220446049250313e-16,
                                 5.273559366969494e-16,
-                                3.552713678800501e-15,
+                                3.552713678800501e-15
                             ],
                             maxiters=1,
                             initial_condition=initial_condition_constant)
@@ -973,13 +973,13 @@ end
                                 0.0021196114178949396,
                                 0.010703549234544042,
                                 0.01070354923454404,
-                                0.10719124037195142,
+                                0.10719124037195142
                             ],
                             linf=[
                                 0.11987270645890724,
                                 0.7468615461136827,
                                 0.7468615461136827,
-                                3.910689155287799,
+                                3.910689155287799
                             ],
                             maxiters=1)
 
diff --git a/test/test_tree_2d_euleracoustics.jl b/test/test_tree_2d_euleracoustics.jl
index e3a4d65f39..2ca893899b 100644
--- a/test/test_tree_2d_euleracoustics.jl
+++ b/test/test_tree_2d_euleracoustics.jl
@@ -22,7 +22,7 @@ EXAMPLES_DIR = joinpath(examples_dir(), "tree_2d_dgsem")
                             13.000001753042364,
                             26.00000080243847,
                             38.00000884725549,
-                            51.000000003859995,
+                            51.000000003859995
                         ],
                         linf=[
                             0.22312716933051027,
@@ -31,7 +31,7 @@ EXAMPLES_DIR = joinpath(examples_dir(), "tree_2d_dgsem")
                             13.468872744263273,
                             26.54666679978679,
                             38.139032147739684,
-                            51.378134660241294,
+                            51.378134660241294
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_tree_2d_eulermulti.jl b/test/test_tree_2d_eulermulti.jl
index 5b98461168..2f460e512f 100644
--- a/test/test_tree_2d_eulermulti.jl
+++ b/test/test_tree_2d_eulermulti.jl
@@ -40,14 +40,14 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                 0.9174752929795251,
                                 57942.83587826468,
                                 0.1828847253029943,
-                                0.011127037850925347,
+                                0.011127037850925347
                             ],
                             linf=[
                                 196.81051991521073,
                                 7.8456811648529605,
                                 158891.88930113698,
                                 0.811379581519794,
-                                0.08011973559187913,
+                                0.08011973559187913
                             ],
                             tspan=(0.0, 0.001))
         # Ensure that we do not have excessive memory allocations
@@ -69,14 +69,14 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                 2.5455678559421346,
                                 63229.190712645846,
                                 0.19929478404550321,
-                                0.011068604228443425,
+                                0.011068604228443425
                             ],
                             linf=[
                                 249.21708417382013,
                                 40.33299887640794,
                                 174205.0118831558,
                                 0.6881458768113586,
-                                0.11274401158173972,
+                                0.11274401158173972
                             ],
                             initial_refinement_level=3,
                             tspan=(0.0, 0.001),
@@ -103,14 +103,14 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                 1.4599090197303102,
                                 57176.23978426408,
                                 0.17812910616624406,
-                                0.010123079422717837,
+                                0.010123079422717837
                             ],
                             linf=[
                                 214.50568817511956,
                                 25.40392579616452,
                                 152862.41011222568,
                                 0.564195553101797,
-                                0.0956331651771212,
+                                0.0956331651771212
                             ],
                             initial_refinement_level=3,
                             tspan=(0.0, 0.001))
@@ -130,13 +130,13 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                 0.050182236154087095,
                                 0.050189894464434635,
                                 0.2258715597305131,
-                                0.06175171559771687,
+                                0.06175171559771687
                             ],
                             linf=[
                                 0.3108124923284472,
                                 0.3107380389947733,
                                 1.054035804988521,
-                                0.29347582879608936,
+                                0.29347582879608936
                             ])
         # Ensure that we do not have excessive memory allocations
         # (e.g., from type instabilities)
@@ -157,7 +157,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                 0.004087155041747821,
                                 0.008174310083495642,
                                 0.016348620166991283,
-                                0.032697240333982566,
+                                0.032697240333982566
                             ],
                             linf=[
                                 0.2488251110766228,
@@ -166,7 +166,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                 0.017452870465607374,
                                 0.03490574093121475,
                                 0.0698114818624295,
-                                0.139622963724859,
+                                0.139622963724859
                             ])
         # Ensure that we do not have excessive memory allocations
         # (e.g., from type instabilities)
@@ -185,14 +185,14 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                 0.00012290225488321876,
                                 0.00018867397906337653,
                                 4.8542321753649044e-5,
-                                9.708464350729809e-5,
+                                9.708464350729809e-5
                             ],
                             linf=[
                                 0.0006722819239133315,
                                 0.0006722819239128874,
                                 0.0012662292789555885,
                                 0.0002843844182700561,
-                                0.0005687688365401122,
+                                0.0005687688365401122
                             ])
         # Ensure that we do not have excessive memory allocations
         # (e.g., from type instabilities)
@@ -211,14 +211,14 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                 2.266177386666318e-6,
                                 6.593514692980009e-6,
                                 8.836308667348217e-7,
-                                1.7672617334696433e-6,
+                                1.7672617334696433e-6
                             ],
                             linf=[
                                 1.4713170997993075e-5,
                                 1.4713170997104896e-5,
                                 5.115618808515521e-5,
                                 5.3639516094383666e-6,
-                                1.0727903218876733e-5,
+                                1.0727903218876733e-5
                             ])
         # Ensure that we do not have excessive memory allocations
         # (e.g., from type instabilities)
@@ -237,14 +237,14 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                 1.862173764098385e-6,
                                 5.942585713809631e-6,
                                 6.216263279534722e-7,
-                                1.2432526559069443e-6,
+                                1.2432526559069443e-6
                             ],
                             linf=[
                                 1.6235495582606063e-5,
                                 1.6235495576388814e-5,
                                 5.854523678827661e-5,
                                 5.790274858807898e-6,
-                                1.1580549717615796e-5,
+                                1.1580549717615796e-5
                             ],
                             volume_flux=flux_chandrashekar)
         # Ensure that we do not have excessive memory allocations
diff --git a/test/test_tree_2d_eulerpolytropic.jl b/test/test_tree_2d_eulerpolytropic.jl
index 545cf7274f..dd6bb5700c 100644
--- a/test/test_tree_2d_eulerpolytropic.jl
+++ b/test/test_tree_2d_eulerpolytropic.jl
@@ -15,11 +15,11 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                                  "elixir_eulerpolytropic_convergence.jl"),
                         l2=[
                             0.0016689832177626373, 0.0025920263793094526,
-                            0.003281074494626679,
+                            0.003281074494626679
                         ],
                         linf=[
                             0.010994883201896677, 0.013309526619350365,
-                            0.02008032661117376,
+                            0.02008032661117376
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_tree_2d_fdsbp.jl b/test/test_tree_2d_fdsbp.jl
index d477cab056..ae0bb4157d 100644
--- a/test/test_tree_2d_fdsbp.jl
+++ b/test/test_tree_2d_fdsbp.jl
@@ -56,13 +56,13 @@ end
                                 1.7088389997042244e-6,
                                 1.7437997855125774e-6,
                                 1.7437997855350776e-6,
-                                5.457223460127621e-6,
+                                5.457223460127621e-6
                             ],
                             linf=[
                                 9.796504903736292e-6,
                                 9.614745892783105e-6,
                                 9.614745892783105e-6,
-                                4.026107182575345e-5,
+                                4.026107182575345e-5
                             ],
                             tspan=(0.0, 0.1))
 
@@ -82,13 +82,13 @@ end
                                 2.1149087345799973e-6,
                                 1.9391438806845798e-6,
                                 1.9391438806759794e-6,
-                                5.842833764682604e-6,
+                                5.842833764682604e-6
                             ],
                             linf=[
                                 1.3679037540903494e-5,
                                 1.1770587849069258e-5,
                                 1.1770587848403125e-5,
-                                4.68952678644996e-5,
+                                4.68952678644996e-5
                             ],
                             tspan=(0.0, 0.1), flux_splitting=splitting_lax_friedrichs)
 
@@ -108,13 +108,13 @@ end
                                 1.708838999643608e-6,
                                 1.7437997854485807e-6,
                                 1.7437997854741082e-6,
-                                5.457223460116349e-6,
+                                5.457223460116349e-6
                             ],
                             linf=[
                                 9.796504911285808e-6,
                                 9.614745899888533e-6,
                                 9.614745899444443e-6,
-                                4.02610718399643e-5,
+                                4.02610718399643e-5
                             ],
                             tspan=(0.0, 0.1), flux_splitting=splitting_drikakis_tsangaris)
 
@@ -135,13 +135,13 @@ end
                                 0.02607850081951497,
                                 0.020357717558016252,
                                 0.028510191844948945,
-                                0.02951535039734857,
+                                0.02951535039734857
                             ],
                             linf=[
                                 0.12185328623662173,
                                 0.1065055387595834,
                                 0.06257122956937419,
-                                0.11992349951978643,
+                                0.11992349951978643
                             ],
                             tspan=(0.0, 0.1))
 
@@ -161,13 +161,13 @@ end
                                 0.0005330228930711585,
                                 0.028475888529345014,
                                 0.02847513865894387,
-                                0.056259951995581196,
+                                0.056259951995581196
                             ],
                             linf=[
                                 0.007206088611304784,
                                 0.31690373882847234,
                                 0.31685665067192326,
-                                0.7938167296134893,
+                                0.7938167296134893
                             ],
                             tspan=(0.0, 0.25))
 
diff --git a/test/test_tree_2d_hypdiff.jl b/test/test_tree_2d_hypdiff.jl
index 8c5973cbf0..a89bbc977c 100644
--- a/test/test_tree_2d_hypdiff.jl
+++ b/test/test_tree_2d_hypdiff.jl
@@ -15,12 +15,12 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                         l2=[
                             0.00015687751817403066,
                             0.001025986772216324,
-                            0.0010259867722164071,
+                            0.0010259867722164071
                         ],
                         linf=[
                             0.001198695637957381,
                             0.006423873515531753,
-                            0.006423873515533529,
+                            0.006423873515533529
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -38,12 +38,12 @@ end
                         l2=[
                             8.618132355121019e-8,
                             5.619399844384306e-7,
-                            5.619399844844044e-7,
+                            5.619399844844044e-7
                         ],
                         linf=[
                             1.1248618588430072e-6,
                             8.622436487026874e-6,
-                            8.622436487915053e-6,
+                            8.622436487915053e-6
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -60,12 +60,12 @@ end
                         l2=[
                             8.523077653954864e-6,
                             2.8779323653020624e-5,
-                            5.454942769125663e-5,
+                            5.454942769125663e-5
                         ],
                         linf=[
                             5.522740952468297e-5,
                             0.00014544895978971679,
-                            0.00032396328684924924,
+                            0.00032396328684924924
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -82,12 +82,12 @@ end
                         l2=[
                             5.868147556427088e-6,
                             3.80517927324465e-5,
-                            3.805179273249344e-5,
+                            3.805179273249344e-5
                         ],
                         linf=[
                             3.701965498725812e-5,
                             0.0002122422943138247,
-                            0.00021224229431116015,
+                            0.00021224229431116015
                         ],
                         atol=2.0e-12) #= required for CI on macOS =#
     # Ensure that we do not have excessive memory allocations
diff --git a/test/test_tree_2d_linearizedeuler.jl b/test/test_tree_2d_linearizedeuler.jl
index 7bdb83e328..b1d34895a6 100644
--- a/test/test_tree_2d_linearizedeuler.jl
+++ b/test/test_tree_2d_linearizedeuler.jl
@@ -15,13 +15,13 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                             0.00020601485381444888,
                             0.00013380483421751216,
                             0.0001338048342174503,
-                            0.00020601485381444888,
+                            0.00020601485381444888
                         ],
                         linf=[
                             0.0011006084408365924,
                             0.0005788678074691855,
                             0.0005788678074701847,
-                            0.0011006084408365924,
+                            0.0011006084408365924
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -39,13 +39,13 @@ end
                             0.048185623945503485,
                             0.01941899333212175,
                             0.019510224816991825,
-                            0.048185623945503485,
+                            0.048185623945503485
                         ],
                         linf=[
                             1.0392165942153189,
                             0.18188777290819994,
                             0.1877028372108587,
-                            1.0392165942153189,
+                            1.0392165942153189
                         ])
 
     # Ensure that we do not have excessive memory allocations
diff --git a/test/test_tree_2d_mhd.jl b/test/test_tree_2d_mhd.jl
index 66b47138a4..bebab54ff0 100644
--- a/test/test_tree_2d_mhd.jl
+++ b/test/test_tree_2d_mhd.jl
@@ -21,7 +21,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                             1.2542675002588144e-6,
                             1.2542675002747718e-6,
                             1.8705223407238346e-6,
-                            4.651717010670585e-7,
+                            4.651717010670585e-7
                         ],
                         linf=[
                             0.00026806333988971254,
@@ -32,7 +32,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_2d_dgsem")
                             8.130129322880819e-6,
                             8.130129322769797e-6,
                             1.2406302192291552e-5,
-                            2.373765544951732e-6,
+                            2.373765544951732e-6
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -55,7 +55,7 @@ end
                             1.07029565814218e-6,
                             1.0702956581404748e-6,
                             1.3291748105236525e-6,
-                            4.6172239295786824e-7,
+                            4.6172239295786824e-7
                         ],
                         linf=[
                             9.865325754310206e-6,
@@ -66,7 +66,7 @@ end
                             7.789533065905019e-6,
                             7.789533065905019e-6,
                             1.0933531593274037e-5,
-                            2.340244047768378e-6,
+                            2.340244047768378e-6
                         ],
                         volume_flux=(flux_derigs_etal, flux_nonconservative_powell))
     # Ensure that we do not have excessive memory allocations
@@ -90,7 +90,7 @@ end
                             1.456369119716533e-6,
                             1.4115666913995062e-6,
                             1.804758237422838e-6,
-                            8.320469738087189e-7,
+                            8.320469738087189e-7
                         ],
                         linf=[
                             3.670661330201774e-5,
@@ -101,7 +101,7 @@ end
                             1.0906323046233624e-5,
                             1.0603954940346938e-5,
                             1.5900499596113726e-5,
-                            5.978772247650426e-6,
+                            5.978772247650426e-6
                         ],
                         tspan=(0.0, 1.0))
     # Ensure that we do not have excessive memory allocations
@@ -125,7 +125,7 @@ end
                             0.01745369341302589,
                             0.017454552320664566,
                             0.026873190440613117,
-                            5.336243933079389e-16,
+                            5.336243933079389e-16
                         ],
                         linf=[
                             0.23623816236321427,
@@ -136,7 +136,7 @@ end
                             0.09398098096581875,
                             0.09470282020962917,
                             0.15277253978297378,
-                            4.307694418935709e-15,
+                            4.307694418935709e-15
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -159,7 +159,7 @@ end
                             0.23028914748088603,
                             0.34413527376463915,
                             0.0,
-                            0.003178793090381426,
+                            0.003178793090381426
                         ],
                         linf=[
                             1.2749969218080568,
@@ -170,7 +170,7 @@ end
                             0.6473347557712643,
                             0.9691773375490476,
                             0.0,
-                            0.05729832038724348,
+                            0.05729832038724348
                         ],
                         tspan=(0.0, 0.09))
     # Ensure that we do not have excessive memory allocations
@@ -194,7 +194,7 @@ end
                             0.15688413207147794,
                             0.24293641543490646,
                             0.0,
-                            0.003246181006326598,
+                            0.003246181006326598
                         ],
                         linf=[
                             0.560316034595759,
@@ -205,7 +205,7 @@ end
                             0.3981375420906146,
                             0.673472146198816,
                             0.0,
-                            0.04879208429337193,
+                            0.04879208429337193
                         ],
                         tspan=(0.0, 0.06),
                         surface_flux=(flux_hlle,
@@ -231,7 +231,7 @@ end
                             3.9171737639099993e-16,
                             2.445565690318772e-16,
                             3.6588423152083e-17,
-                            9.971153407737885e-17,
+                            9.971153407737885e-17
                         ],
                         linf=[
                             2.220446049250313e-16,
@@ -242,7 +242,7 @@ end
                             8.881784197001252e-16,
                             4.440892098500626e-16,
                             1.1102230246251565e-16,
-                            4.779017148551244e-16,
+                            4.779017148551244e-16
                         ],
                         maxiters=1,
                         initial_condition=initial_condition_constant,
@@ -268,7 +268,7 @@ end
                             0.2147235065899803,
                             0.23558337696054493,
                             0.0,
-                            0.0032515115395693483,
+                            0.0032515115395693483
                         ],
                         linf=[
                             11.003677581472843,
@@ -279,7 +279,7 @@ end
                             1.3283750501377847,
                             1.4365828094434892,
                             0.0,
-                            0.07886241196068537,
+                            0.07886241196068537
                         ],
                         tspan=(0.0, 0.05))
     # Ensure that we do not have excessive memory allocations
@@ -303,7 +303,7 @@ end
                             2.359493623565687,
                             1.4030741420730297,
                             0.0,
-                            0.029613599942667133,
+                            0.029613599942667133
                         ],
                         linf=[
                             1.581630420824181,
@@ -314,7 +314,7 @@ end
                             13.07679044647926,
                             9.14612176426092,
                             0.0,
-                            0.5154756722488522,
+                            0.5154756722488522
                         ],
                         tspan=(0.0, 0.003),
                         # Calling the AnalysisCallback before iteration 9 causes the interpolation
@@ -341,7 +341,7 @@ end
                             8.4091669534557805e-03,
                             5.2156364913231732e-03,
                             0.0000000000000000e+00,
-                            2.0786952301129021e-04,
+                            2.0786952301129021e-04
                         ],
                         linf=[
                             3.8778760255775635e-01,
@@ -352,7 +352,7 @@ end
                             1.0264404591009069e-01,
                             1.0655686942176350e-01,
                             0.0000000000000000e+00,
-                            6.1013422157115546e-03,
+                            6.1013422157115546e-03
                         ],
                         tspan=(0.0, 0.003))
     # Ensure that we do not have excessive memory allocations 
diff --git a/test/test_tree_2d_shallowwater.jl b/test/test_tree_2d_shallowwater.jl
index 9a3ba36c7d..08be40d4b6 100644
--- a/test/test_tree_2d_shallowwater.jl
+++ b/test/test_tree_2d_shallowwater.jl
@@ -16,13 +16,13 @@ EXAMPLES_DIR = joinpath(examples_dir(), "tree_2d_dgsem")
                             0.9911802019934329,
                             0.7340106828033273,
                             0.7446338002084801,
-                            0.5875351036989047,
+                            0.5875351036989047
                         ],
                         linf=[
                             2.0120253138457564,
                             2.991158989293406,
                             2.6557412817714035,
-                            3.0,
+                            3.0
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations
@@ -41,13 +41,13 @@ end
                             0.9130579602987144,
                             1.0602847041965408e-14,
                             1.082225645390032e-14,
-                            0.9130579602987147,
+                            0.9130579602987147
                         ],
                         linf=[
                             2.113062037615659,
                             4.6613606802974e-14,
                             5.4225772771633196e-14,
-                            2.1130620376156584,
+                            2.1130620376156584
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations
@@ -67,13 +67,13 @@ end
                             0.9130579602987144,
                             1.0602847041965408e-14,
                             1.082225645390032e-14,
-                            0.9130579602987147,
+                            0.9130579602987147
                         ],
                         linf=[
                             2.113062037615659,
                             4.6613606802974e-14,
                             5.4225772771633196e-14,
-                            2.1130620376156584,
+                            2.1130620376156584
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations
@@ -92,13 +92,13 @@ end
                             0.9130579602987147,
                             9.68729463970494e-15,
                             9.694538537436981e-15,
-                            0.9130579602987147,
+                            0.9130579602987147
                         ],
                         linf=[
                             2.1130620376156584,
                             2.3875905654916432e-14,
                             2.2492839032269154e-14,
-                            2.1130620376156584,
+                            2.1130620376156584
                         ],
                         surface_flux=(FluxHydrostaticReconstruction(flux_lax_friedrichs,
                                                                     hydrostatic_reconstruction_audusse_etal),
@@ -120,13 +120,13 @@ end
                             0.9130579602987146,
                             1.0323158914614244e-14,
                             1.0276096319430528e-14,
-                            0.9130579602987147,
+                            0.9130579602987147
                         ],
                         linf=[
                             2.11306203761566,
                             4.063916419044386e-14,
                             3.694484044448245e-14,
-                            2.1130620376156584,
+                            2.1130620376156584
                         ],
                         surface_flux=(flux_wintermeyer_etal,
                                       flux_nonconservative_ersing_etal),
@@ -149,13 +149,13 @@ end
                             0.001868474306068482,
                             0.01731687445878443,
                             0.017649083171490863,
-                            6.274146767717023e-5,
+                            6.274146767717023e-5
                         ],
                         linf=[
                             0.016962486402209986,
                             0.08768628853889782,
                             0.09038488750767648,
-                            0.0001819675955490041,
+                            0.0001819675955490041
                         ],
                         tspan=(0.0, 0.025))
     # Ensure that we do not have excessive memory allocations
@@ -175,13 +175,13 @@ end
                             0.0018746929418489125,
                             0.017332321628469628,
                             0.01634953679145536,
-                            6.274146767717023e-5,
+                            6.274146767717023e-5
                         ],
                         linf=[
                             0.016262353691956388,
                             0.08726160620859424,
                             0.09043621801418844,
-                            0.0001819675955490041,
+                            0.0001819675955490041
                         ],
                         tspan=(0.0, 0.025))
     # Ensure that we do not have excessive memory allocations
@@ -200,13 +200,13 @@ end
                             0.0018952610547425214,
                             0.016943425162728183,
                             0.017556784292859465,
-                            6.274146767717414e-5,
+                            6.274146767717414e-5
                         ],
                         linf=[
                             0.0151635341334182,
                             0.07967467926956129,
                             0.08400050790965174,
-                            0.0001819675955490041,
+                            0.0001819675955490041
                         ],
                         tspan=(0.0, 0.025),
                         surface_flux=(flux_hll,
@@ -227,13 +227,13 @@ end
                             0.0018957692481057034,
                             0.016943229710439864,
                             0.01755623297390675,
-                            6.274146767717414e-5,
+                            6.274146767717414e-5
                         ],
                         linf=[
                             0.015156105797771602,
                             0.07964811135780492,
                             0.0839787097210376,
-                            0.0001819675955490041,
+                            0.0001819675955490041
                         ],
                         tspan=(0.0, 0.025),
                         surface_flux=(FluxHLL(min_max_speed_naive),
@@ -254,13 +254,13 @@ end
                             0.002471853426064005,
                             0.05619168608950033,
                             0.11844727575152562,
-                            6.274146767730281e-5,
+                            6.274146767730281e-5
                         ],
                         linf=[
                             0.014332922987500218,
                             0.2141204806174546,
                             0.5392313755637872,
-                            0.0001819675955490041,
+                            0.0001819675955490041
                         ],
                         surface_flux=(flux_wintermeyer_etal,
                                       flux_nonconservative_ersing_etal),
@@ -283,13 +283,13 @@ end
                             0.1351723240085936,
                             0.20010881416550014,
                             0.2001088141654999,
-                            2.719538414346464e-7,
+                            2.719538414346464e-7
                         ],
                         linf=[
                             0.5303608302490757,
                             0.5080987791967457,
                             0.5080987791967506,
-                            1.1301675764130437e-6,
+                            1.1301675764130437e-6
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations
diff --git a/test/test_tree_3d_euler.jl b/test/test_tree_3d_euler.jl
index 47669dce2f..03ff2c5378 100644
--- a/test/test_tree_3d_euler.jl
+++ b/test/test_tree_3d_euler.jl
@@ -17,14 +17,14 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_3d_dgsem")
                             0.009776048833895767,
                             0.00977604883389591,
                             0.009776048833895733,
-                            0.01506687097416608,
+                            0.01506687097416608
                         ],
                         linf=[
                             0.03285848350791731,
                             0.0321792316408982,
                             0.032179231640894645,
                             0.032179231640895534,
-                            0.0655408023333299,
+                            0.0655408023333299
                         ],
                         # With the default `maxiters = 1` in coverage tests,
                         # there would be no time series to check against.
@@ -51,21 +51,21 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_3d_dgsem")
             1.952073047561595,
             1.9520730475615966,
             1.9520730475615953,
-            3.814390510967551,
+            3.814390510967551
         ],
         [
             2.0506452262144363,
             2.050727319703708,
             2.0507273197037073,
             2.0507273197037077,
-            4.203653999433724,
+            4.203653999433724
         ],
         [
             2.046982357537558,
             2.0463728824399654,
             2.0463728824399654,
             2.0463728824399645,
-            4.190033459318115,
+            4.190033459318115
         ]]
     @test point_data≈exact_data atol=1e-1
     @test point_data ≈ ref_data
@@ -78,14 +78,14 @@ end
                             0.032062252638283974,
                             0.032062252638283974,
                             0.03206225263828395,
-                            0.12228177813586687,
+                            0.12228177813586687
                         ],
                         linf=[
                             0.0693648413632646,
                             0.0622101894740843,
                             0.06221018947408474,
                             0.062210189474084965,
-                            0.24196451799555962,
+                            0.24196451799555962
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -104,14 +104,14 @@ end
                             0.009776048833894784,
                             0.009776048833894784,
                             0.009776048833894765,
-                            0.015066870974164096,
+                            0.015066870974164096
                         ],
                         linf=[
                             0.03285848350791687,
                             0.032179231640897754,
                             0.0321792316408942,
                             0.0321792316408982,
-                            0.06554080233333615,
+                            0.06554080233333615
                         ],
                         volume_integral=VolumeIntegralFluxDifferencing(flux_central))
     # Ensure that we do not have excessive memory allocations
@@ -129,12 +129,12 @@ end
                         l2=[
                             0.0003637241020254673, 0.00039555708663848046,
                             0.00039555708663832644, 0.0003955570866385083,
-                            0.0007811613481643962,
+                            0.0007811613481643962
                         ],
                         linf=[
                             0.0024000660244567484, 0.002963541002521053,
                             0.0029635410025201647, 0.002963541002522385,
-                            0.007191437359379549,
+                            0.007191437359379549
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -153,14 +153,14 @@ end
                             0.0018659907926698422,
                             0.0018659907926698589,
                             0.0018659907926698747,
-                            0.0034549095578444056,
+                            0.0034549095578444056
                         ],
                         linf=[
                             0.011355360771142298,
                             0.011526889155693887,
                             0.011526889155689002,
                             0.011526889155701436,
-                            0.02299726519821288,
+                            0.02299726519821288
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -179,14 +179,14 @@ end
                             0.003828192061340465,
                             0.0038281920613404694,
                             0.0038281920613404672,
-                            0.005742288092010652,
+                            0.005742288092010652
                         ],
                         linf=[
                             0.07390396464027349,
                             0.07390396464027305,
                             0.07390396464027305,
                             0.07390396464027305,
-                            0.11085594696041134,
+                            0.11085594696041134
                         ],
                         tspan=(0.0, 0.1),
                         coverage_override=(maxiters = 6, initial_refinement_level = 0,
@@ -208,14 +208,14 @@ end
                             0.03133384111621587,
                             0.03133384111621582,
                             0.04378599329988925,
-                            0.015796137903453026,
+                            0.015796137903453026
                         ],
                         linf=[
                             0.0013935237751798724,
                             0.0724080091006194,
                             0.07240800910061806,
                             0.12795921224174792,
-                            0.07677156293692633,
+                            0.07677156293692633
                         ],
                         tspan=(0.0, 0.5))
     # Ensure that we do not have excessive memory allocations
@@ -235,14 +235,14 @@ end
                             0.016179934130642552,
                             0.01617993413064253,
                             0.016172648598753545,
-                            0.09261669328795467,
+                            0.09261669328795467
                         ],
                         linf=[
                             0.3954458125573179,
                             0.26876916180359345,
                             0.26876916180359345,
                             0.26933123042178553,
-                            1.3724137121660251,
+                            1.3724137121660251
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -264,14 +264,14 @@ end
                             0.012771561294571411,
                             0.01277156129457143,
                             0.012770635779336643,
-                            0.08091898488262424,
+                            0.08091898488262424
                         ],
                         linf=[
                             0.4047819603427084,
                             0.27493532130155474,
                             0.2749353213015551,
                             0.2749304638368023,
-                            1.4053942765487641,
+                            1.4053942765487641
                         ],
                         maxiters=10,
                         coverage_override=(maxiters = 2,))
@@ -292,14 +292,14 @@ end
                             0.057196526814004715,
                             0.05719652681400473,
                             0.057196526814004736,
-                            0.08579479022100575,
+                            0.08579479022100575
                         ],
                         linf=[
                             0.27415246703018203,
                             0.2741524670301829,
                             0.2741524670301827,
                             0.27415246703018226,
-                            0.41122870054527816,
+                            0.41122870054527816
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -318,14 +318,14 @@ end
                             0.016632068583699623,
                             0.016632068583699623,
                             0.01662548715216875,
-                            0.0913477018048886,
+                            0.0913477018048886
                         ],
                         linf=[
                             0.4372549540810414,
                             0.28613118232798984,
                             0.28613118232799006,
                             0.28796686065271876,
-                            1.5072828647309124,
+                            1.5072828647309124
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -344,14 +344,14 @@ end
                             6.059779958716338e-16,
                             4.916596221090319e-16,
                             9.739943366304456e-16,
-                            3.7485908743251566e-15,
+                            3.7485908743251566e-15
                         ],
                         linf=[
                             2.4424906541753444e-15,
                             3.733124920302089e-15,
                             4.440892098500626e-15,
                             5.329070518200751e-15,
-                            2.4868995751603507e-14,
+                            2.4868995751603507e-14
                         ],
                         initial_condition=initial_condition_constant)
     # Ensure that we do not have excessive memory allocations
@@ -371,14 +371,14 @@ end
                             0.016649800693500427,
                             0.01664980069350042,
                             0.01664379306708522,
-                            0.09137248646784184,
+                            0.09137248646784184
                         ],
                         linf=[
                             0.4373399329742198,
                             0.28434487167605427,
                             0.28434487167605427,
                             0.28522678968890774,
-                            1.532471676033761,
+                            1.532471676033761
                         ],
                         surface_flux=flux_chandrashekar, volume_flux=flux_chandrashekar)
     # Ensure that we do not have excessive memory allocations
@@ -398,14 +398,14 @@ end
                             0.016675487948639846,
                             0.016675487948639853,
                             0.016668992714991282,
-                            0.091455613470441,
+                            0.091455613470441
                         ],
                         linf=[
                             0.43348628145015766,
                             0.28853549062014217,
                             0.28853549062014217,
                             0.2903943042772536,
-                            1.5236557526482426,
+                            1.5236557526482426
                         ],
                         surface_flux=flux_kennedy_gruber,
                         volume_flux=flux_kennedy_gruber)
@@ -426,14 +426,14 @@ end
                             0.016637655557848952,
                             0.01663765555784895,
                             0.01663105921013437,
-                            0.09136239054024566,
+                            0.09136239054024566
                         ],
                         linf=[
                             0.43692416928732536,
                             0.28622033209064734,
                             0.28622033209064746,
                             0.2881197143457632,
-                            1.506534270303663,
+                            1.506534270303663
                         ],
                         surface_flux=flux_shima_etal, volume_flux=flux_shima_etal)
     # Ensure that we do not have excessive memory allocations
@@ -453,14 +453,14 @@ end
                             0.2640486962336911,
                             0.0354927658652858,
                             0.03549276586528571,
-                            1.0777274757408568,
+                            1.0777274757408568
                         ],
                         linf=[
                             9.558543313792217,
                             49.4518309553356,
                             10.319859082570309,
                             10.319859082570487,
-                            195.1066220797401,
+                            195.1066220797401
                         ],
                         tspan=(0.0, 0.2),
                         # Let this test run longer to cover some lines in the positivity preserving limiter
@@ -483,14 +483,14 @@ end
                             0.0023166296394624025,
                             0.002316629639462401,
                             0.0023166296394624038,
-                            0.010200581509653256,
+                            0.010200581509653256
                         ],
                         linf=[
                             0.06344190883105805,
                             0.6292607955969378,
                             0.6292607955969377,
                             0.6292607955969377,
-                            2.397746252817731,
+                            2.397746252817731
                         ],
                         maxiters=5, max_level=6,
                         surface_flux=FluxHLL(min_max_speed_naive),
@@ -513,14 +513,14 @@ end
                             0.0037168004033428146,
                             0.0037168004033428094,
                             0.0037168004033428514,
-                            0.011119869089205635,
+                            0.011119869089205635
                         ],
                         linf=[
                             0.13982864363612468,
                             0.786004687738243,
                             0.786004687738243,
                             0.7860046877382431,
-                            1.7082524045150382,
+                            1.7082524045150382
                         ],
                         tspan=(0.0, 0.01),
                         surface_flux=flux_hlle)
diff --git a/test/test_tree_3d_eulergravity.jl b/test/test_tree_3d_eulergravity.jl
index 1b5e715f77..a1eedd1444 100644
--- a/test/test_tree_3d_eulergravity.jl
+++ b/test/test_tree_3d_eulergravity.jl
@@ -17,14 +17,14 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_3d_dgsem")
                             0.00047204222332596204,
                             0.00047204222332608705,
                             0.0004720422233259819,
-                            0.0010987026250960728,
+                            0.0010987026250960728
                         ],
                         linf=[
                             0.003496616916238704,
                             0.003764418290373106,
                             0.003764418290377103,
                             0.0037644182903766588,
-                            0.008370424899251105,
+                            0.008370424899251105
                         ],
                         resid_tol=1.0e-4, tspan=(0.0, 0.2))
     # Ensure that we do not have excessive memory allocations
diff --git a/test/test_tree_3d_fdsbp.jl b/test/test_tree_3d_fdsbp.jl
index e0e2bfe4b8..4cac601171 100644
--- a/test/test_tree_3d_fdsbp.jl
+++ b/test/test_tree_3d_fdsbp.jl
@@ -57,14 +57,14 @@ end
                                 2.2499169224681058e-5,
                                 2.24991692246826e-5,
                                 2.2499169224684707e-5,
-                                5.814121361417382e-5,
+                                5.814121361417382e-5
                             ],
                             linf=[
                                 9.579357410749445e-5,
                                 9.544871933409027e-5,
                                 9.54487193367548e-5,
                                 9.544871933453436e-5,
-                                0.0004192294529472562,
+                                0.0004192294529472562
                             ],
                             tspan=(0.0, 0.2))
 
@@ -85,14 +85,14 @@ end
                                 4.1320630860402814e-5,
                                 4.132063086040211e-5,
                                 4.132063086039092e-5,
-                                8.502518355874354e-5,
+                                8.502518355874354e-5
                             ],
                             linf=[
                                 0.0001963934848161486,
                                 0.00020239883896255861,
                                 0.0002023988389729947,
                                 0.00020239883896766564,
-                                0.00052605624510349,
+                                0.00052605624510349
                             ],
                             tspan=(0.0, 0.2),
                             solver=DG(D_upw.central, nothing, SurfaceIntegralStrongForm(),
@@ -115,14 +115,14 @@ end
                                 0.0004691301922633193,
                                 0.00046913019226332234,
                                 0.0006630180220973541,
-                                0.0015732759680929076,
+                                0.0015732759680929076
                             ],
                             linf=[
                                 3.4253965106145756e-5,
                                 0.0010033197685090707,
                                 0.0010033197685091054,
                                 0.0018655642702542635,
-                                0.008479800046757191,
+                                0.008479800046757191
                             ],
                             tspan=(0.0, 0.0075), abstol=1.0e-9, reltol=1.0e-9)
 
diff --git a/test/test_tree_3d_hypdiff.jl b/test/test_tree_3d_hypdiff.jl
index 5c9dacbd87..921047ff4b 100644
--- a/test/test_tree_3d_hypdiff.jl
+++ b/test/test_tree_3d_hypdiff.jl
@@ -16,13 +16,13 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_3d_dgsem")
                             0.001530331609036682,
                             0.011314177033289238,
                             0.011314177033289402,
-                            0.011314177033289631,
+                            0.011314177033289631
                         ],
                         linf=[
                             0.02263459033909354,
                             0.10139777904683545,
                             0.10139777904683545,
-                            0.10139777904683545,
+                            0.10139777904683545
                         ],
                         initial_refinement_level=2)
     # Ensure that we do not have excessive memory allocations
@@ -41,13 +41,13 @@ end
                             0.0015377731806850128,
                             0.01137685274151801,
                             0.011376852741518175,
-                            0.011376852741518494,
+                            0.011376852741518494
                         ],
                         linf=[
                             0.022715420630041172,
                             0.10183745338964201,
                             0.10183745338964201,
-                            0.1018374533896429,
+                            0.1018374533896429
                         ],
                         initial_refinement_level=2, surface_flux=flux_godunov)
     # Ensure that we do not have excessive memory allocations
@@ -66,13 +66,13 @@ end
                             0.00022868320512754316,
                             0.0007974309948540525,
                             0.0015035143230654987,
-                            0.0015035143230655293,
+                            0.0015035143230655293
                         ],
                         linf=[
                             0.0016405001653623241,
                             0.0029870057159104594,
                             0.009410031618285686,
-                            0.009410031618287462,
+                            0.009410031618287462
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_tree_3d_linearizedeuler.jl b/test/test_tree_3d_linearizedeuler.jl
index 00f8d62dad..0390b0cbcf 100644
--- a/test/test_tree_3d_linearizedeuler.jl
+++ b/test/test_tree_3d_linearizedeuler.jl
@@ -14,12 +14,12 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_3d_dgsem")
                         l2=[
                             0.020380328336745232, 0.027122442311921492,
                             0.02712244231192152, 8.273108096127844e-17,
-                            0.020380328336745232,
+                            0.020380328336745232
                         ],
                         linf=[
                             0.2916021983572774, 0.32763703462270843,
                             0.32763703462270855, 1.641012595221666e-15,
-                            0.2916021983572774,
+                            0.2916021983572774
                         ],
                         tspan=(0.0, 1.0))
 
diff --git a/test/test_tree_3d_mhd.jl b/test/test_tree_3d_mhd.jl
index 74107d462d..98016cb519 100644
--- a/test/test_tree_3d_mhd.jl
+++ b/test/test_tree_3d_mhd.jl
@@ -21,7 +21,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_3d_dgsem")
                             0.010391801950005755,
                             0.010391801950005759,
                             0.010393502246627087,
-                            2.524766553484067e-16,
+                            2.524766553484067e-16
                         ],
                         linf=[
                             0.28173002819718196,
@@ -32,7 +32,7 @@ EXAMPLES_DIR = pkgdir(Trixi, "examples", "tree_3d_dgsem")
                             0.10950981489747313,
                             0.10950981489747136,
                             0.11517234329681891,
-                            2.0816911067714202e-15,
+                            2.0816911067714202e-15
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -55,7 +55,7 @@ end
                             1.0340110783830874e-15,
                             1.1779095371939702e-15,
                             9.961878521814573e-16,
-                            8.1201730630719145e-16,
+                            8.1201730630719145e-16
                         ],
                         linf=[
                             2.4424906541753444e-15,
@@ -66,7 +66,7 @@ end
                             1.7763568394002505e-14,
                             1.0436096431476471e-14,
                             2.042810365310288e-14,
-                            7.057203733035201e-15,
+                            7.057203733035201e-15
                         ],
                         atol=1000 * eps(),
                         initial_condition=initial_condition_constant)
@@ -91,7 +91,7 @@ end
                             0.00916500047763897,
                             0.005069863732625444,
                             0.011503011541926135,
-                            0.003988175543749985,
+                            0.003988175543749985
                         ],
                         linf=[
                             0.01188593784273051,
@@ -102,7 +102,7 @@ end
                             0.03316343064943483,
                             0.011539436992528018,
                             0.04896687646520839,
-                            0.018714054039927555,
+                            0.018714054039927555
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -125,7 +125,7 @@ end
                             0.00900886245212482,
                             0.004926537542780259,
                             0.01153285554590683,
-                            0.0037842060148666886,
+                            0.0037842060148666886
                         ],
                         linf=[
                             0.012982853115883541,
@@ -136,7 +136,7 @@ end
                             0.03198699034954189,
                             0.009761077061886558,
                             0.04433669321441455,
-                            0.01618905441148782,
+                            0.01618905441148782
                         ],
                         volume_flux=(flux_derigs_etal, flux_nonconservative_powell))
     # Ensure that we do not have excessive memory allocations
@@ -160,7 +160,7 @@ end
                             0.007328739509868727,
                             0.00309794018112387,
                             0.009026356949274878,
-                            0.0035732583778049776,
+                            0.0035732583778049776
                         ],
                         linf=[
                             0.013734346970999622,
@@ -171,7 +171,7 @@ end
                             0.055120532123884625,
                             0.018202716205672487,
                             0.06133688282205586,
-                            0.019888161885935608,
+                            0.019888161885935608
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations
@@ -197,7 +197,7 @@ end
                             0.021125605214031118,
                             0.03295607553556973,
                             0.03296235755245784,
-                            7.16035229384135e-6,
+                            7.16035229384135e-6
                         ],
                         linf=[
                             0.017894703320895378,
@@ -208,7 +208,7 @@ end
                             0.05381260695579509,
                             0.0884774018719996,
                             0.07784546966765199,
-                            7.71609149516089e-5,
+                            7.71609149516089e-5
                         ],
                         initial_condition=function initial_condition_orszag_tang(x, t,
                                                                                  equations::IdealGlmMhdEquations3D)
@@ -269,7 +269,7 @@ end
                             0.007355137041002365,
                             0.0073551370410023425,
                             0.00735520932001833,
-                            0.000506140942330923,
+                            0.000506140942330923
                         ],
                         linf=[
                             0.28040713666979633,
@@ -280,7 +280,7 @@ end
                             0.08770240288089526,
                             0.08770240288089792,
                             0.08773409387876674,
-                            0.050221095224119834,
+                            0.050221095224119834
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
diff --git a/test/test_unit.jl b/test/test_unit.jl
index d7ec208436..4704901355 100644
--- a/test/test_unit.jl
+++ b/test/test_unit.jl
@@ -1282,7 +1282,7 @@ end
         0.5011914484393387,
         0.8829127712445113,
         0.43024132987932817,
-        0.7560616633050348,
+        0.7560616633050348
     ]
 
     equations = CompressibleEulerEquations2D(1.4)
@@ -1440,7 +1440,7 @@ end
             SVector(1.5, -0.2, 0.1, 5.0)]
         fluxes = [flux_central, flux_ranocha, flux_shima_etal, flux_kennedy_gruber,
             FluxLMARS(340), flux_hll, FluxHLL(min_max_speed_davis), flux_hlle,
-            flux_hllc, flux_chandrashekar,
+            flux_hllc, flux_chandrashekar
         ]
 
         for f_std in fluxes
@@ -1465,7 +1465,7 @@ end
             SVector(1.5, -0.2, 0.1, 0.2, 5.0)]
         fluxes = [flux_central, flux_ranocha, flux_shima_etal, flux_kennedy_gruber,
             FluxLMARS(340), flux_hll, FluxHLL(min_max_speed_davis), flux_hlle,
-            flux_hllc, flux_chandrashekar,
+            flux_hllc, flux_chandrashekar
         ]
 
         for f_std in fluxes
@@ -1504,7 +1504,7 @@ end
             flux_central,
             flux_hindenlang_gassner,
             FluxHLL(min_max_speed_davis),
-            flux_hlle,
+            flux_hlle
         ]
 
         for f_std in fluxes
@@ -1531,7 +1531,7 @@ end
             flux_central,
             flux_hindenlang_gassner,
             FluxHLL(min_max_speed_davis),
-            flux_hlle,
+            flux_hlle
         ]
 
         for f_std in fluxes
diff --git a/test/test_unstructured_2d.jl b/test/test_unstructured_2d.jl
index 5c228d1e04..c87abfa0b3 100644
--- a/test/test_unstructured_2d.jl
+++ b/test/test_unstructured_2d.jl
@@ -18,11 +18,11 @@ isdir(outdir) && rm(outdir, recursive = true)
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_periodic.jl"),
                         l2=[
                             0.0001099216141882387, 0.0001303795774982892,
-                            0.00013037957749794242, 0.0002993727892598759,
+                            0.00013037957749794242, 0.0002993727892598759
                         ],
                         linf=[
                             0.006407280810928562, 0.009836067015418948,
-                            0.009836067015398076, 0.021903519038095176,
+                            0.009836067015398076, 0.021903519038095176
                         ])
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -38,11 +38,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_euler_free_stream.jl"),
                         l2=[
                             3.3937365073416665e-14, 2.44759188939065e-13,
-                            1.4585198700082895e-13, 4.716940764877479e-13,
+                            1.4585198700082895e-13, 4.716940764877479e-13
                         ],
                         linf=[
                             7.774003663030271e-12, 9.183176441496244e-11,
-                            4.5685344396417804e-11, 1.0534506600379245e-10,
+                            4.5685344396417804e-11, 1.0534506600379245e-10
                         ],
                         tspan=(0.0, 0.1),
                         atol=3.0e-13)
@@ -62,13 +62,13 @@ end
                             0.040189107976346644,
                             0.04256154998030852,
                             0.03734120743842209,
-                            0.10057425897733507,
+                            0.10057425897733507
                         ],
                         linf=[
                             0.24455374304626365,
                             0.2970686406973577,
                             0.29339040847600434,
-                            0.5915610037764794,
+                            0.5915610037764794
                         ],
                         tspan=(0.0, 0.25),
                         surface_flux=FluxHLL(min_max_speed_naive))
@@ -88,13 +88,13 @@ end
                             0.0007213418215265047,
                             0.0006752337675043779,
                             0.0006437485997536973,
-                            0.0014782883071363362,
+                            0.0014782883071363362
                         ],
                         linf=[
                             0.004301288971032324,
                             0.005243995459478956,
                             0.004685630332338153,
-                            0.01750217718347713,
+                            0.01750217718347713
                         ],
                         tspan=(0.0, 1.0))
     # Ensure that we do not have excessive memory allocations
@@ -113,13 +113,13 @@ end
                             0.0007213418215265047,
                             0.0006752337675043779,
                             0.0006437485997536973,
-                            0.0014782883071363362,
+                            0.0014782883071363362
                         ],
                         linf=[
                             0.004301288971032324,
                             0.005243995459478956,
                             0.004685630332338153,
-                            0.01750217718347713,
+                            0.01750217718347713
                         ],
                         # With the default `maxiters = 1` in coverage tests,
                         # there would be no time steps after the restart.
@@ -140,13 +140,13 @@ end
                             0.06594600495903137,
                             0.10803914821786433,
                             0.10805946357846291,
-                            0.1738171782368222,
+                            0.1738171782368222
                         ],
                         linf=[
                             0.31880214280781305,
                             0.3468488554333352,
                             0.34592958184413264,
-                            0.784555926860546,
+                            0.784555926860546
                         ],
                         tspan=(0.0, 1.0))
     # Ensure that we do not have excessive memory allocations
@@ -179,13 +179,13 @@ end
                             2.19945600e-01,
                             1.71050453e-01,
                             1.71050453e-01,
-                            1.21719195e+00,
+                            1.21719195e+00
                         ],
                         linf=[
                             7.44218635e-01,
                             7.02887039e-01,
                             7.02887039e-01,
-                            6.11732719e+00,
+                            6.11732719e+00
                         ],
                         tspan=(0.0, 0.3))
     # Ensure that we do not have excessive memory allocations
@@ -204,13 +204,13 @@ end
                             6.984024099236519e-5,
                             6.289022520363763e-5,
                             6.550951878107466e-5,
-                            0.00016222767700879948,
+                            0.00016222767700879948
                         ],
                         linf=[
                             0.0005367823248620951,
                             0.000671293180158461,
                             0.0005656680962440319,
-                            0.0013910024779804075,
+                            0.0013910024779804075
                         ],
                         tspan=(0.0, 0.2),
                         # With the default `maxiters = 1` in coverage tests,
@@ -304,13 +304,13 @@ end
                             0.6107326269462766,
                             0.48666631722018877,
                             0.48309775159067053,
-                            0.29467422718511704,
+                            0.29467422718511704
                         ],
                         linf=[
                             2.776782342826098,
                             3.2158378644333707,
                             3.652920889487258,
-                            2.052861364219655,
+                            2.052861364219655
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations
@@ -329,13 +329,13 @@ end
                             1.2164292510839076,
                             2.6118925543469468e-12,
                             2.459878823146057e-12,
-                            1.2164292510839079,
+                            1.2164292510839079
                         ],
                         linf=[
                             1.5138512282315846,
                             4.706289937431355e-11,
                             4.913910192312011e-11,
-                            1.513851228231574,
+                            1.513851228231574
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations
@@ -354,13 +354,13 @@ end
                             1.2164292510839085,
                             1.2643106818778908e-12,
                             1.269230436589819e-12,
-                            1.2164292510839079,
+                            1.2164292510839079
                         ],
                         linf=[
                             1.513851228231562,
                             1.6670644673575802e-11,
                             1.8426585188623954e-11,
-                            1.513851228231574,
+                            1.513851228231574
                         ],
                         surface_flux=(FluxHydrostaticReconstruction(flux_lax_friedrichs,
                                                                     hydrostatic_reconstruction_audusse_etal),
@@ -382,13 +382,13 @@ end
                             1.2164292510839083,
                             2.590643638636187e-12,
                             2.388742604639019e-12,
-                            1.2164292510839079,
+                            1.2164292510839079
                         ],
                         linf=[
                             1.5138512282315792,
                             4.761278694199934e-11,
                             4.910549479958249e-11,
-                            1.513851228231574,
+                            1.513851228231574
                         ],
                         surface_flux=(flux_wintermeyer_etal,
                                       flux_nonconservative_ersing_etal),
@@ -411,13 +411,13 @@ end
                             0.001118134082248467,
                             0.044560486817464634,
                             0.01430926600634214,
-                            5.089218476759981e-6,
+                            5.089218476759981e-6
                         ],
                         linf=[
                             0.007798727223654822,
                             0.34782952734839157,
                             0.11161614702628064,
-                            2.6407324614341476e-5,
+                            2.6407324614341476e-5
                         ],
                         tspan=(0.0, 0.025))
     # Ensure that we do not have excessive memory allocations
@@ -436,13 +436,13 @@ end
                             0.0011196838135485918,
                             0.01542895635133927,
                             0.017082803023121197,
-                            5.089218476759981e-6,
+                            5.089218476759981e-6
                         ],
                         linf=[
                             0.014299541415654371,
                             0.12783948113206955,
                             0.17626489583921323,
-                            2.6407324614341476e-5,
+                            2.6407324614341476e-5
                         ],
                         surface_flux=(FluxHydrostaticReconstruction(flux_hll,
                                                                     hydrostatic_reconstruction_audusse_etal),
@@ -464,13 +464,13 @@ end
                             0.001118046975499805,
                             0.04455969246244461,
                             0.014298120235633432,
-                            5.089218476759981e-6,
+                            5.089218476759981e-6
                         ],
                         linf=[
                             0.007776521213640031,
                             0.34768318303226353,
                             0.11075311228066198,
-                            2.6407324614341476e-5,
+                            2.6407324614341476e-5
                         ],
                         surface_flux=(flux_wintermeyer_etal,
                                       flux_nonconservative_ersing_etal),
@@ -493,13 +493,13 @@ end
                             0.0011196838135486059,
                             0.015428956351339451,
                             0.017082803023120943,
-                            5.089218476759981e-6,
+                            5.089218476759981e-6
                         ],
                         linf=[
                             0.01429954141565526,
                             0.12783948113205668,
                             0.176264895839215,
-                            2.6407324614341476e-5,
+                            2.6407324614341476e-5
                         ],
                         surface_flux=(flux_hll,
                                       flux_nonconservative_fjordholm_etal),
@@ -518,11 +518,11 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_shallowwater_dirichlet.jl"),
                         l2=[
                             1.1577518608938916e-5, 4.859252379740366e-13,
-                            4.639600837197925e-13, 1.1577518608952174e-5,
+                            4.639600837197925e-13, 1.1577518608952174e-5
                         ],
                         linf=[
                             8.3940638787805e-5, 1.1446362498574484e-10,
-                            1.1124515748367981e-10, 8.39406387962427e-5,
+                            1.1124515748367981e-10, 8.39406387962427e-5
                         ],
                         tspan=(0.0, 2.0))
     # Ensure that we do not have excessive memory allocations
@@ -540,11 +540,11 @@ end
                                  "elixir_shallowwater_wall_bc_shockcapturing.jl"),
                         l2=[
                             0.0442113635677511, 0.1537465759364839, 0.16003586586203947,
-                            6.225080477067782e-8,
+                            6.225080477067782e-8
                         ],
                         linf=[
                             0.6347820607387928, 2.0078125433846736, 2.530726684667019,
-                            3.982097165344811e-7,
+                            3.982097165344811e-7
                         ],
                         tspan=(0.0, 0.05))
     # Ensure that we do not have excessive memory allocations
@@ -564,13 +564,13 @@ end
                             0.612551520607341,
                             0.5039173660221961,
                             0.49136517934903523,
-                            0.29467422718511704,
+                            0.29467422718511704
                         ],
                         linf=[
                             2.7636771472622197,
                             3.236168963021072,
                             3.3363936775653826,
-                            2.052861364219655,
+                            2.052861364219655
                         ],
                         tspan=(0.0, 0.25))
     # Ensure that we do not have excessive memory allocations

From d3ecf34664e6d347ecf8742fed6d8c1eb307555c Mon Sep 17 00:00:00 2001
From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com>
Date: Tue, 2 Jul 2024 13:32:27 +0200
Subject: [PATCH 11/13] Update src/time_integration/methods_IMEXJinXin.jl

Co-authored-by: Hendrik Ranocha <ranocha@users.noreply.github.com>
---
 src/time_integration/methods_IMEXJinXin.jl | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index d8234d0ce5..268d70ec0b 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -16,7 +16,7 @@ abstract type SimpleAlgorithmIMEX end
 
 ## References
 
-- missing
+- TODO: missing
 
 !!! warning "Experimental implementation"
     This is an experimental feature and may change in future releases.

From a2fba8884d6cdddb12d1862a83e3090197f66729 Mon Sep 17 00:00:00 2001
From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com>
Date: Tue, 2 Jul 2024 13:32:36 +0200
Subject: [PATCH 12/13] Update src/time_integration/methods_IMEXJinXin.jl

Co-authored-by: Hendrik Ranocha <ranocha@users.noreply.github.com>
---
 src/time_integration/methods_IMEXJinXin.jl | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index 268d70ec0b..8e8979115a 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -30,11 +30,6 @@ struct SimpleIMEX{StageCallbacks} <: SimpleAlgorithmIMEX
     stage_callbacks::StageCallbacks
 
     function SimpleIMEX(; stage_callbacks = ())
-        # Mathematically speaking, it is not necessary for the algorithm to split the factors
-        # into numerator and denominator. Otherwise, however, rounding errors of the order of
-        # the machine accuracy will occur, which will add up over time and thus endanger the
-        # conservation of the simulation.
-        # See also https://github.com/trixi-framework/Trixi.jl/pull/1640.
         A1 = zeros(3, 3)
         A2 = zeros(3, 3)
         A1[2, 1] = 0.5

From c9b21a589aeb510295b23f1af0e9ee2014d62c9a Mon Sep 17 00:00:00 2001
From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com>
Date: Tue, 2 Jul 2024 13:32:51 +0200
Subject: [PATCH 13/13] Update src/time_integration/methods_IMEXJinXin.jl

Co-authored-by: Hendrik Ranocha <ranocha@users.noreply.github.com>
---
 src/time_integration/methods_IMEXJinXin.jl | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/src/time_integration/methods_IMEXJinXin.jl b/src/time_integration/methods_IMEXJinXin.jl
index 8e8979115a..776ceff41d 100644
--- a/src/time_integration/methods_IMEXJinXin.jl
+++ b/src/time_integration/methods_IMEXJinXin.jl
@@ -146,15 +146,6 @@ function Base.getproperty(integrator::SimpleIntegratorIMEX, field::Symbol)
     return getfield(integrator, field)
 end
 
-"""
-    solve(ode, alg; dt, callbacks, kwargs...)
-
-The following structures and methods provide the infrastructure for SSP Runge-Kutta methods
-of type `SimpleAlgorithmSSP`.
-
-!!! warning "Experimental implementation"
-    This is an experimental feature and may change in future releases.
-"""
 function solve(ode::ODEProblem, alg::SimpleAlgorithmIMEX;
                dt, callback = nothing, kwargs...)
     u = copy(ode.u0)