22503087308

Committed 27 Feb 2026 08:43PM UTC coverage: 85.574% (-11.6%) from 97.128%

Build # 22503087308

Build Type

push

github

Committed by

web-flow

Commit Message

Avoid repeated global memory operations in `prolong2interfaces!` for Gauss nodes (#2830)

* prolong2interfaces! 1D

* 2D

* Apply suggestions from code review

---------

Co-authored-by: Daniel Doehring <daniel.doehring@rwth-aachen.de>

Coverage Stats

12 of 18 new or added lines in 2 files covered. (66.67%)

5301 existing lines in 247 files now uncovered.

39316 of 45944 relevant lines covered (85.57%)

29718441.76 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/examples/structured_3d_dgsem/elixir_euler_source_terms.jl

# The same setup as tree_3d_dgsem/elixir_euler_source_terms.jl
# to verify the StructuredMesh implementation against TreeMesh

using OrdinaryDiffEqLowStorageRK
using Trixi

###############################################################################
# semidiscretization of the compressible Euler equations

equations = CompressibleEulerEquations3D(1.4)

initial_condition = initial_condition_convergence_test

# Up to version 0.13.0, `max_abs_speed_naive` was used as the default wave speed estimate of
# `const flux_lax_friedrichs = FluxLaxFriedrichs(), i.e., `FluxLaxFriedrichs(max_abs_speed = max_abs_speed_naive)`.
# In the `StepsizeCallback`, though, the less diffusive `max_abs_speeds` is employed which is consistent with `max_abs_speed`.
# Thus, we exchanged in PR#2458 the default wave speed used in the LLF flux to `max_abs_speed`.
# To ensure that every example still runs we specify explicitly `FluxLaxFriedrichs(max_abs_speed_naive)`.
# We remark, however, that the now default `max_abs_speed` is in general recommended due to compliance with the
# `StepsizeCallback` (CFL-Condition) and less diffusion.
solver = DGSEM(polydeg = 3, surface_flux = FluxLaxFriedrichs(max_abs_speed_naive),
               volume_integral = VolumeIntegralWeakForm())

# coordinates_min = (0.0, 0.0, 0.0)
# coordinates_max = (2.0, 2.0, 2.0)
f1(s, t) = SVector(0.0, s + 1.0, t + 1.0)
f2(s, t) = SVector(2.0, s + 1.0, t + 1.0)
f3(s, t) = SVector(s + 1.0, 0.0, t + 1.0)
f4(s, t) = SVector(s + 1.0, 2.0, t + 1.0)
f5(s, t) = SVector(s + 1.0, t + 1.0, 0.0)
f6(s, t) = SVector(s + 1.0, t + 1.0, 2.0)

cells_per_dimension = (4, 4, 4)

mesh = StructuredMesh(cells_per_dimension, (f1, f2, f3, f4, f5, f6), periodicity = true)

semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver;
                                    source_terms = source_terms_convergence_test,
                                    boundary_conditions = boundary_condition_periodic)

###############################################################################
# ODE solvers, callbacks etc.

tspan = (0.0, 5.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)

save_solution = SaveSolutionCallback(interval = 100,
                                     save_initial_solution = true,
                                     save_final_solution = true,
                                     solution_variables = cons2prim)

stepsize_callback = StepsizeCallback(cfl = 0.6)

callbacks = CallbackSet(summary_callback,
                        analysis_callback, alive_callback,
                        save_solution,
                        stepsize_callback)

###############################################################################
# run the simulation

sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
            dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
            ode_default_options()..., callback = callbacks);

1	# The same setup as tree_3d_dgsem/elixir_euler_source_terms.jl
2	# to verify the StructuredMesh implementation against TreeMesh
3
4	using OrdinaryDiffEqLowStorageRK
5	using Trixi
6
7	###############################################################################
8	# semidiscretization of the compressible Euler equations
9
10	equations = CompressibleEulerEquations3D(1.4)
11
12	initial_condition = initial_condition_convergence_test
13
14	# Up to version 0.13.0, `max_abs_speed_naive` was used as the default wave speed estimate of
15	# `const flux_lax_friedrichs = FluxLaxFriedrichs(), i.e., `FluxLaxFriedrichs(max_abs_speed = max_abs_speed_naive)`.
16	# In the `StepsizeCallback`, though, the less diffusive `max_abs_speeds` is employed which is consistent with `max_abs_speed`.
17	# Thus, we exchanged in PR#2458 the default wave speed used in the LLF flux to `max_abs_speed`.
18	# To ensure that every example still runs we specify explicitly `FluxLaxFriedrichs(max_abs_speed_naive)`.
19	# We remark, however, that the now default `max_abs_speed` is in general recommended due to compliance with the
20	# `StepsizeCallback` (CFL-Condition) and less diffusion.
21	solver = DGSEM(polydeg = 3, surface_flux = FluxLaxFriedrichs(max_abs_speed_naive),
22	volume_integral = VolumeIntegralWeakForm())
23
24	# coordinates_min = (0.0, 0.0, 0.0)
25	# coordinates_max = (2.0, 2.0, 2.0)
UNCOV 26	f1(s, t) = SVector(0.0, s + 1.0, t + 1.0)	×
UNCOV 27	f2(s, t) = SVector(2.0, s + 1.0, t + 1.0)	×
UNCOV 28	f3(s, t) = SVector(s + 1.0, 0.0, t + 1.0)	×
UNCOV 29	f4(s, t) = SVector(s + 1.0, 2.0, t + 1.0)	×
UNCOV 30	f5(s, t) = SVector(s + 1.0, t + 1.0, 0.0)	×
UNCOV 31	f6(s, t) = SVector(s + 1.0, t + 1.0, 2.0)	×
32
33	cells_per_dimension = (4, 4, 4)
34
35	mesh = StructuredMesh(cells_per_dimension, (f1, f2, f3, f4, f5, f6), periodicity = true)
36
37	semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver;
38	source_terms = source_terms_convergence_test,
39	boundary_conditions = boundary_condition_periodic)
40
41	###############################################################################
42	# ODE solvers, callbacks etc.
43
44	tspan = (0.0, 5.0)
45	ode = semidiscretize(semi, tspan)
46
47	summary_callback = SummaryCallback()
48
49	analysis_interval = 100
50	analysis_callback = AnalysisCallback(semi, interval = analysis_interval)
51
52	alive_callback = AliveCallback(analysis_interval = analysis_interval)
53
54	save_solution = SaveSolutionCallback(interval = 100,
55	save_initial_solution = true,
56	save_final_solution = true,
57	solution_variables = cons2prim)
58
59	stepsize_callback = StepsizeCallback(cfl = 0.6)
60
61	callbacks = CallbackSet(summary_callback,
62	analysis_callback, alive_callback,
63	save_solution,
64	stepsize_callback)
65
66	###############################################################################
67	# run the simulation
68
69	sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
70	dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
71	ode_default_options()..., callback = callbacks);

trixi-framework / Trixi.jl / 22503087308

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous