Apply suggestions from code review

Co-authored-by: Hendrik Ranocha <[email protected]>

Author: DanielDoehring

examples/tree_1d_dgsem/elixir_advection_diffusion_implicit_sparse_jacobian.jl

@@ -75,7 +75,7 @@ jac_prototype_parabolic = jacobian_sparsity(rhs_parabolic_wrapped!, du_ode, u0_o
 # For most efficient solving we also want the coloring vector
 
 # We choose `nonsymmetric` `structure` because we're computing a Jacobian, which
-# is for the Upwind-alike discretization of the advection term nonsymmmetric
+# is for the upwind-alike discretization of the advection term nonsymmmetric
 # We arbitrarily choose a column-based `partitioning`. This means that we will color
 # structurally orthogonal columns the same. `row` partitioning would be equally valid here
 coloring_prob = ColoringProblem(; structure = :nonsymmetric, partition = :column)
@@ -89,24 +89,24 @@ coloring_vec_parabolic = column_colors(coloring_result)
 ### sparsity-aware semidiscretization and ODE ###
 
 # Semidiscretization for actual simulation. `uEltype` is here retrieved from `solver`
-semi_float_type = SemidiscretizationHyperbolicParabolic(mesh,
-                                                        (equations_hyperbolic,
-                                                         equations_parabolic),
-                                                        initial_condition, solver)
+semi= = SemidiscretizationHyperbolicParabolic(mesh,
+                                              (equations_hyperbolic,
+                                               equations_parabolic),
+                                              initial_condition, solver)
 
 # Supply Jacobian prototype and coloring vector to the semidiscretization
-ode_jac_sparse = semidiscretize(semi_float_type, tspan,
-                                jac_prototype_parabolic = jac_prototype_parabolic,
-                                colorvec_parabolic = coloring_vec_parabolic)
-# using "dense" `ode = semidiscretize(semi_float_type, tspan)` is 4-6 times slower!
+ode = semidiscretize(semi, tspan,
+                     jac_prototype_parabolic = jac_prototype_parabolic,
+                     colorvec_parabolic = coloring_vec_parabolic)
+# using "dense" `ode = semidiscretize(semi, tspan)` is 4-6 times slower!
 
 ###############################################################################
 ### callbacks  ###
 
 summary_callback = SummaryCallback()
 
 analysis_interval = 100
-analysis_callback = AnalysisCallback(semi_float_type, interval = analysis_interval)
+analysis_callback = AnalysisCallback(semi, interval = analysis_interval)
 
 alive_callback = AliveCallback(analysis_interval = analysis_interval)
 
@@ -119,7 +119,8 @@ callbacks = CallbackSet(summary_callback, analysis_callback, alive_callback, sav
 ###############################################################################
 ### solve the ODE problem ###
 
-sol = solve(ode_jac_sparse, SBDF2(; autodiff = AutoFiniteDiff());
-            dt = 0.01, save_everystep = false,
+sol = solve(ode, SBDF2(; autodiff = AutoFiniteDiff());
+            ode_default_options()...,
+            dt = 0.01,
             abstol = 1e-9, reltol = 1e-9,
-            ode_default_options()..., callback = callbacks)
+            callback = callbacks)

examples/tree_1d_dgsem/elixir_advection_diffusion_implicit_sparse_jacobian_restart.jl

@@ -14,16 +14,17 @@ restart_filename = joinpath("out", restart_file)
 tspan = (load_time(restart_filename), 2.0)
 dt_restart = load_dt(restart_filename)
 
-ode_jac_sparse = semidiscretize(semi_float_type, tspan,
-                                restart_filename,
-                                jac_prototype_parabolic = jac_prototype_parabolic,
-                                colorvec_parabolic = coloring_vec_parabolic)
+ode = semidiscretize(semi, tspan,
+                     restart_filename,
+                     jac_prototype_parabolic = jac_prototype_parabolic,
+                     colorvec_parabolic = coloring_vec_parabolic)
 
 ###############################################################################
 # run the simulation
 
 sol = solve(ode_jac_sparse,
             SBDF2(; autodiff = AutoFiniteDiff());
-            dt = dt_restart, save_everystep = false,
+            ode_default_options()...,
+            dt = dt_restart,
             abstol = 1e-9, reltol = 1e-9,
             callback = callbacks);

src/semidiscretization/semidiscretization_hyperbolic_parabolic.jl

@@ -277,8 +277,8 @@ SciML ecosystem.
 Optional keyword arguments:
 - `jac_prototype_parabolic`: Expected to come from [SparseConnectivityTracer.jl](https://github.com/adrhill/SparseConnectivityTracer.jl).
   Specifies the sparsity structure of the parabolic function's Jacobian to enable e.g. efficient implicit time stepping.
-  The [SplitODEProblem](https://docs.sciml.ai/DiffEqDocs/stable/types/split_ode_types/#SciMLBase.SplitODEProblem) only expects the Jacobian
-  to be defined on the first function it takes in, which is treated implicitly. This corresponds to the parabolic right-hand side in Trixi.
+  The [`SplitODEProblem`](https://docs.sciml.ai/DiffEqDocs/stable/types/split_ode_types/#SciMLBase.SplitODEProblem) only expects the Jacobian
+  to be defined on the first function it takes in, which is treated implicitly. This corresponds to the parabolic right-hand side in Trixi.jl.
   The hyperbolic right-hand side is expected to be treated explicitly, and therefore its Jacobian is irrelevant.
 - `colorvec_parabolic`: Expected to come from [SparseMatrixColorings.jl](https://github.com/gdalle/SparseMatrixColorings.jl).
   Allows for even faster Jacobian computation. Not necessarily required when `jac_prototype_parabolic` is given.