Use ode_default_options() consistently

benchmark/elixir_2d_euler_vortex_p4est.jl

@@ -79,6 +79,6 @@ callbacks = CallbackSet(summary_callback, analysis_callback, alive_callback)
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, BS3(),
-            save_everystep = false, callback = callbacks);
+sol = solve(ode, BS3();
+            ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

benchmark/elixir_2d_euler_vortex_structured.jl

@@ -78,6 +78,6 @@ callbacks = CallbackSet(summary_callback, analysis_callback, alive_callback)
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, BS3(),
-            save_everystep = false, callback = callbacks);
+sol = solve(ode, BS3();
+            ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

benchmark/elixir_2d_euler_vortex_tree.jl

@@ -79,6 +79,6 @@ callbacks = CallbackSet(summary_callback, analysis_callback, alive_callback)
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, BS3(),
-            save_everystep = false, callback = callbacks);
+sol = solve(ode, BS3();
+            ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

benchmark/elixir_2d_euler_vortex_unstructured.jl

@@ -78,6 +78,6 @@ callbacks = CallbackSet(summary_callback, analysis_callback, alive_callback)
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, BS3(),
-            save_everystep = false, callback = callbacks);
+sol = solve(ode, BS3();
+            ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

benchmark/elixir_3d_euler_source_terms_structured.jl

@@ -37,6 +37,6 @@ callbacks = CallbackSet(summary_callback, analysis_callback, alive_callback)
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, BS3(),
-            save_everystep = false, callback = callbacks);
+sol = solve(ode, BS3();
+            ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

benchmark/elixir_3d_euler_source_terms_tree.jl

@@ -38,6 +38,6 @@ callbacks = CallbackSet(summary_callback, analysis_callback, alive_callback)
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, BS3(),
-            save_everystep = false, callback = callbacks);
+sol = solve(ode, BS3();
+            ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

docs/literate/src/files/DGMulti_1.jl

@@ -44,8 +44,8 @@ analysis_callback = AnalysisCallback(semi, interval = 100, uEltype = real(dg))
 callbacks = CallbackSet(analysis_callback, alive_callback);
 
 # Run the simulation with the same time integration algorithm as before.
-sol = solve(ode, RDPK3SpFSAL49(), abstol = 1.0e-6, reltol = 1.0e-6,
-            callback = callbacks, save_everystep = false);
+sol = solve(ode, RDPK3SpFSAL49(), abstol = 1.0e-6, reltol = 1.0e-6;
+            callback = callbacks, ode_default_options()...);
 #-
 using Plots
 pd = PlotData2D(sol)
@@ -182,8 +182,8 @@ alive_callback = AliveCallback(alive_interval = 20)
 analysis_callback = AnalysisCallback(semi, interval = 200, uEltype = real(dg))
 callbacks = CallbackSet(alive_callback, analysis_callback);
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = 0.5 * estimate_dt(mesh, dg), save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = 0.5 * estimate_dt(mesh, dg), ode_default_options()..., callback = callbacks);
 #-
 using Plots
 pd = PlotData2D(sol)

docs/literate/src/files/adaptive_mesh_refinement.jl

@@ -148,9 +148,9 @@ stepsize_callback = StepsizeCallback(cfl = 0.9)
 callbacks = CallbackSet(amr_callback, stepsize_callback);
 
 # Running the simulation.
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
+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);
+            ode_default_options()..., callback = callbacks);
 
 # We plot the solution and add the refined mesh at the end of the simulation.
 using Plots

docs/literate/src/files/adding_nonconservative_equation.jl

@@ -131,8 +131,8 @@ callbacks = CallbackSet(summary_callback, analysis_callback)
 
 ## OrdinaryDiffEq's `solve` method evolves the solution in time and executes
 ## the passed callbacks
-sol = solve(ode, Tsit5(), abstol = 1.0e-6, reltol = 1.0e-6,
-            save_everystep = false, callback = callbacks)
+sol = solve(ode, Tsit5(), abstol = 1.0e-6, reltol = 1.0e-6;
+            ode_default_options()..., callback = callbacks)
 
 ## Print the timer summary
 summary_callback()
@@ -164,8 +164,8 @@ summary_callback = SummaryCallback()
 analysis_callback = AnalysisCallback(semi, interval = 50)
 callbacks = CallbackSet(summary_callback, analysis_callback);
 
-sol = solve(ode, Tsit5(), abstol = 1.0e-6, reltol = 1.0e-6,
-            save_everystep = false, callback = callbacks);
+sol = solve(ode, Tsit5(), abstol = 1.0e-6, reltol = 1.0e-6;
+            ode_default_options()..., callback = callbacks);
 summary_callback()
 
 #nb #-
@@ -283,8 +283,8 @@ callbacks = CallbackSet(summary_callback, analysis_callback);
 
 ## OrdinaryDiffEq's `solve` method evolves the solution in time and executes
 ## the passed callbacks
-sol = solve(ode, Tsit5(), abstol = 1.0e-6, reltol = 1.0e-6,
-            save_everystep = false);
+sol = solve(ode, Tsit5(), abstol = 1.0e-6, reltol = 1.0e-6;
+            ode_default_options()...);
 
 ## Plot the numerical solution at the final time
 using Plots: plot

docs/literate/src/files/behind_the_scenes_simulation_setup.jl

@@ -214,8 +214,8 @@ ode = semidiscretize(semi, (0.0, 1.0));
 # the OrdinaryDiffEq.jl package can be utilized to compute an approximated solution using the
 # instructions contained in the `ODEProblem` object.
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false), dt = 0.01,
-            save_everystep = false);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false), dt = 0.01;
+            ode_default_options()...);
 
 # Since the `solve` function and the ODE solver have no knowledge
 # of a particular spatial discretization, it is necessary to define a

docs/literate/src/files/behind_the_scenes_simulation_setup_plots/README.md

@@ -12,4 +12,4 @@ To generate a specific image, run the following command while replacing `"path/t
 ```julia
 pkg> activate .
 julia> include(joinpath("path/to/src", "file_name"))
-```
+```

docs/literate/src/files/differentiable_programming.jl

@@ -230,7 +230,7 @@ function energy_at_final_time(k) # k is the wave number of the initial condition
     semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver,
                                         uEltype = typeof(k))
     ode = semidiscretize(semi, (0.0, 1.0))
-    sol = solve(ode, BS3(), save_everystep = false)
+    sol = solve(ode, BS3(), ode_default_options()...)
     Trixi.integrate(energy_total, sol.u[end], semi)
 end
 
@@ -280,7 +280,7 @@ function energy_at_final_time(k) # k is the wave number of the initial condition
     semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver,
                                         uEltype = typeof(k))
     ode = semidiscretize(semi, (0.0, 1.0))
-    sol = solve(ode, BS3(), save_everystep = false)
+    sol = solve(ode, BS3(), ode_default_options()...)
     Trixi.integrate(energy_total, sol.u[end], semi)
 end
 
@@ -330,7 +330,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition, solver,
 # does. This is basically the only part where you need to modify your standard Trixi.jl
 # code to enable automatic differentiation. From there on, the remaining steps
 ode = semidiscretize(semi, (0.0, 1.0))
-sol = solve(ode, BS3(), save_everystep = false)
+sol = solve(ode, BS3(), ode_default_options()...)
 round(Trixi.integrate(energy_total, sol.u[end], semi), sigdigits = 5)
 @test round(Trixi.integrate(energy_total, sol.u[end], semi), sigdigits = 5) == 0.24986 #src
 
@@ -362,7 +362,7 @@ semi = SemidiscretizationHyperbolic(mesh, equations, initial_condition_convergen
 
 ode = semidiscretize(semi, (0.0, 1.5))
 
-sol = solve(ode, BS3(), save_everystep = false);
+sol = solve(ode, BS3(), ode_default_options()...);
 
 plot(sol)
 

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

@@ -195,7 +195,7 @@ callbacks = CallbackSet(summary_callback, analysis_callback, alive_callback,
 # need to save every step of the solution, as we are only interested the output provided by 
 # our callback [`SaveSolutionCallback`](@ref).
 
-sol = solve(ode, SSPRK33(); dt = 1.0, save_everystep = false, callback = callbacks);
+sol = solve(ode, SSPRK33(); dt = 1.0, ode_default_options()..., callback = callbacks);
 
 # Finally, we print the timer summary.
 

docs/literate/src/files/hohqmesh_tutorial.jl

@@ -366,9 +366,9 @@ callbacks = CallbackSet(summary_callback, save_solution, stepsize_callback)
 
 redirect_stdio(stdout = devnull, stderr = devnull) do # code that prints annoying stuff we don't want to see here #hide #md
     ## Evolve ODE problem in time using `solve` from OrdinaryDiffEq
-    sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
+    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)
+                ode_default_options()..., callback = callbacks)
     ## print the timer summary
     summary_callback()
 end #hide #md

docs/literate/src/files/non_periodic_boundaries.jl

@@ -93,9 +93,9 @@ callbacks = CallbackSet(analysis_callback,
 visnodes = range(tspan[1], tspan[2], length = 300)
 
 # and run the simulation.
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
             dt = 1, # solve needs some value here but it will be overwritten by the stepsize_callback
-            save_everystep = false, saveat = visnodes, callback = callbacks);
+            ode_default_options()..., saveat = visnodes, callback = callbacks);
 
 using Plots
 @gif for step in eachindex(sol.u)

docs/literate/src/files/shock_capturing.jl

@@ -213,9 +213,9 @@ callbacks = CallbackSet(analysis_callback, stepsize_callback);
 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, CarpenterKennedy2N54(stage_limiter!, 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);
+            ode_default_options()..., callback = callbacks);
 
 using Plots
 plot(sol)

docs/literate/src/files/structured_mesh_mapping.jl

@@ -104,9 +104,9 @@ callbacks = CallbackSet(analysis_callback,
                         stepsize_callback);
 
 # Running the simulation
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
+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);
+            ode_default_options()..., callback = callbacks);
 
 using Plots
 plot(sol)
@@ -165,9 +165,9 @@ stepsize_callback = StepsizeCallback(cfl = 0.8)
 callbacks = CallbackSet(analysis_callback,
                         stepsize_callback)
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
+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);
+            ode_default_options()..., callback = callbacks);
 
 # Now, we want to verify the free-stream preservation property and plot the mesh. For the verification,
 # we calculate the absolute difference of the first conservation variable density `u[1]` and `1.0`.

docs/src/conventions.md

@@ -168,4 +168,4 @@ In general, in the case of integer numbers, our developers should apply a case-b
 ### Notes
 1. If the function gets a local pointwise vector of the solution variables `u` such as `flux(u, equations)`, use `u` to determine the real type `eltype(u)`.
 2. If `u` is not passed as an argument but a vector of coordinates `x` such as `initial_condition(x, t, equations)`, use `eltype(x)` instead.
-3. Choose an appropriate argument to determine the real type otherwise.
+3. Choose an appropriate argument to determine the real type otherwise.

docs/src/meshes/p4est_mesh.md

@@ -599,4 +599,4 @@ A simple mesh file, which is used also in `examples/p4est_3d_dgsem/elixir_euler_
 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 
 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 
 94, 95, 96, 97, 98, 
-```
+```

docs/src/time_integration.md

@@ -165,9 +165,9 @@ With everything set up, you can now use `Trixi.solve` to solve the ODE problem.
 
 ```@example PERK-example-1
 # Solve the ODE problem using PERK2
-sol = Trixi.solve(ode, ode_algorithm,
+sol = Trixi.solve(ode, ode_algorithm;
                   dt = 1.0, # overwritten by `stepsize_callback`
-                  save_everystep = false, callback = callbacks)
+                  ode_default_options()..., callback = callbacks)
 ```
 
 ##### Advanced constructors:
@@ -212,4 +212,4 @@ Then, the stable CFL number can be computed as described above.
 ##### Single/Standalone methods
 
 - [`Trixi.PairedExplicitRK2`](@ref): Second-order PERK method with at least two stages.
-- [`Trixi.PairedExplicitRK3`](@ref): Third-order PERK method with at least three stages.
+- [`Trixi.PairedExplicitRK3`](@ref): Third-order PERK method with at least three stages.

examples/dgmulti_1d/elixir_advection_gauss_sbp.jl

@@ -59,8 +59,8 @@ callbacks = CallbackSet(summary_callback, analysis_callback, stepsize_callback)
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = 1.0, save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = 1.0, ode_default_options()..., callback = callbacks);
 
 # Print the timer summary
 summary_callback()

examples/dgmulti_1d/elixir_burgers_gauss_shock_capturing.jl

@@ -64,5 +64,5 @@ callbacks = CallbackSet(summary_callback, analysis_callback, stepsize_callback)
 # ###############################################################################
 # # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = 1.0, save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = 1.0, ode_default_options()..., callback = callbacks);

examples/dgmulti_1d/elixir_euler_fdsbp_periodic.jl

@@ -32,6 +32,6 @@ callbacks = CallbackSet(summary_callback, alive_callback, stepsize_callback,
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = 0.5 * estimate_dt(mesh, dg), save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = 0.5 * estimate_dt(mesh, dg), ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

examples/dgmulti_1d/elixir_euler_flux_diff.jl

@@ -31,7 +31,7 @@ callbacks = CallbackSet(summary_callback,
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = 0.5 * estimate_dt(mesh, dg), save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = 0.5 * estimate_dt(mesh, dg), ode_default_options()..., callback = callbacks);
 
 summary_callback() # print the timer summary

examples/dgmulti_1d/elixir_euler_quasi_1d.jl

@@ -43,7 +43,7 @@ callbacks = CallbackSet(summary_callback,
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
+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);
+            ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

examples/dgmulti_1d/elixir_euler_shu_osher_gauss_shock_capturing.jl

@@ -89,6 +89,6 @@ callbacks = CallbackSet(summary_callback, analysis_callback, stepsize_callback)
 # ###############################################################################
 # # run the simulation
 
-sol = solve(ode, SSPRK43(), adaptive = false,
+sol = solve(ode, SSPRK43(), adaptive = false;
             dt = 1.0, # solve needs some value here but it will be overwritten by the stepsize_callback
-            callback = callbacks, save_everystep = false)
+            callback = callbacks, ode_default_options()...)

examples/dgmulti_2d/elixir_euler_fdsbp_periodic.jl

@@ -32,6 +32,6 @@ callbacks = CallbackSet(summary_callback, alive_callback, stepsize_callback,
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = 0.5 * estimate_dt(mesh, dg), save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = 0.5 * estimate_dt(mesh, dg), ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

examples/dgmulti_2d/elixir_euler_kelvin_helmholtz_instability.jl

@@ -50,7 +50,7 @@ callbacks = CallbackSet(summary_callback,
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = estimate_dt(mesh, dg), save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = estimate_dt(mesh, dg), ode_default_options()..., callback = callbacks);
 
 summary_callback() # print the timer summary

examples/dgmulti_2d/elixir_euler_triangulate_pkg_mesh.jl

@@ -35,6 +35,6 @@ callbacks = CallbackSet(summary_callback, alive_callback, analysis_callback)
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = 0.5 * estimate_dt(mesh, dg), save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = 0.5 * estimate_dt(mesh, dg), ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

examples/dgmulti_2d/elixir_euler_weakform.jl

@@ -38,6 +38,6 @@ callbacks = CallbackSet(summary_callback, alive_callback, stepsize_callback,
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = 0.5 * estimate_dt(mesh, dg), save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = 0.5 * estimate_dt(mesh, dg), ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

examples/dgmulti_2d/elixir_euler_weakform_periodic.jl

@@ -25,6 +25,6 @@ callbacks = CallbackSet(summary_callback, alive_callback, analysis_callback)
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
-            dt = 0.5 * estimate_dt(mesh, dg), save_everystep = false, callback = callbacks);
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
+            dt = 0.5 * estimate_dt(mesh, dg), ode_default_options()..., callback = callbacks);
 summary_callback() # print the timer summary

examples/dgmulti_2d/elixir_mhd_reflective_wall.jl

@@ -102,8 +102,8 @@ callbacks = CallbackSet(summary_callback,
 ###############################################################################
 # run the simulation
 
-sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false),
+sol = solve(ode, CarpenterKennedy2N54(williamson_condition = false);
             dt = 1e-5, # solve needs some value here but it will be overwritten by the stepsize_callback
-            save_everystep = false, callback = callbacks);
+            ode_default_options()..., callback = callbacks);
 
 summary_callback() # print the timer summary