update to TrixiTest.jl v2

examples/p4est_2d_dgsem/elixir_advection_basic_gpu.jl

@@ -19,7 +19,7 @@ coordinates_max = (1.0, 1.0) # maximum coordinates (max(x), max(y))
 trees_per_dimension = (8, 8)
 
 # Create P4estMesh with 8 x 8 trees and 16 x 16 elements
-mesh = P4estMesh(trees_per_dimension, polydeg = 3,
+mesh = P4estMesh(trees_per_dimension, polydeg = 3, RealT = Float64,
                  coordinates_min = coordinates_min, coordinates_max = coordinates_max,
                  initial_refinement_level = 1)
 

test/Project.toml

@@ -74,4 +74,4 @@ SparseConnectivityTracer = "1.0.1"
 SparseMatrixColorings = "0.4.21"
 StableRNGs = "1.0.2"
 Test = "1"
-TrixiTest = "0.1.4"
+TrixiTest = "0.2"

test/test_cuda.jl

@@ -41,7 +41,7 @@ end
                         # Expected errors are exactly the same as with TreeMesh!
                         l2=nothing,   # TODO: GPU. [Float32(8.311947673061856e-6)],
                         linf=nothing, # TODO: GPU. [Float32(6.627000273229378e-5)],
-                        RealT=Float32,
+                        RealT_for_test_tolerances=Float32,
                         real_type=Float32,
                         storage_type=CuArray,
                         sol=nothing,) # TODO: GPU. Remove this once we can run the simulation on the GPU

test/test_p4est_2d.jl

@@ -35,7 +35,7 @@ end
                         # Expected errors are exactly the same as with TreeMesh!
                         l2=[Float32(8.311947673061856e-6)],
                         linf=[Float32(6.627000273229378e-5)],
-                        RealT=Float32,
+                        RealT_for_test_tolerances=Float32,
                         real_type=Float32)
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
@@ -278,7 +278,7 @@ end
                         ],
                         tspan=(0.0f0, 1.0f0),
                         rtol=10 * sqrt(eps(Float32)), # to make CI pass
-                        RealT=Float32)
+                        RealT_for_test_tolerances=Float32)
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
     @test_allocations(Trixi.rhs!, semi, sol, 1000)

test/test_p4est_3d.jl

@@ -215,20 +215,20 @@ end
     @test_trixi_include(joinpath(EXAMPLES_DIR,
                                  "elixir_euler_free_stream_boundaries_float32.jl"),
                         l2=[
-                            Float32(6.530157034651212e-16),
-                            Float32(1.6057829680004379e-15),
-                            Float32(3.31107455378537e-15),
-                            Float32(3.908829498281281e-15),
-                            Float32(5.048390610424672e-15)
+                            3.8734996f-7,
+                            1.2929888f-6,
+                            2.4713074f-6,
+                            2.9541036f-6,
+                            3.292966f-6
                         ],
                         linf=[
-                            Float32(4.884981308350689e-15),
-                            Float32(1.1921019726912618e-14),
-                            Float32(1.5432100042289676e-14),
-                            Float32(2.298161660974074e-14),
-                            Float32(6.039613253960852e-14)
+                            2.8014183f-6,
+                            9.417534f-6,
+                            1.1667609f-5,
+                            1.692772f-5,
+                            3.33786f-5
                         ],
-                        RealT=Float32)
+                        RealT_for_test_tolerances=Float32)
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
     @test_allocations(Trixi.rhs!, semi, sol, 1000)

test/test_structured_2d.jl

@@ -28,9 +28,9 @@ end
     # Expected errors are taken from elixir_advection_basic.jl
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_advection_float32.jl"),
                         # Expected errors are taken from elixir_advection_basic.jl
-                        l2=[Float32(8.311947673061856e-6)],
-                        linf=[Float32(6.627000273229378e-5)],
-                        RealT=Float32)
+                        l2=8.477608f-6,
+                        linf=7.224083f-5,
+                        RealT_for_test_tolerances=Float32)
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
     @test_allocations(Trixi.rhs!, semi, sol, 1000)

test/test_tree_2d_mhd.jl

@@ -159,25 +159,26 @@ end
 
 @trixi_testset "elixir_mhd_ec_float32.jl" begin
     @test_trixi_include(joinpath(EXAMPLES_DIR, "elixir_mhd_ec_float32.jl"),
-                        l2=Float32[0.03635566,
-                                   0.042947732,
-                                   0.042947736,
-                                   0.025748001,
-                                   0.16211228,
-                                   0.01745248,
-                                   0.017452491,
-                                   0.026877586,
-                                   2.417227f-7],
-                        linf=Float32[0.2210092,
-                                     0.28798974,
-                                     0.28799006,
-                                     0.20858109,
-                                     0.8812673,
-                                     0.09208107,
-                                     0.09208131,
-                                     0.14795369,
-                                     2.2078211f-6],
-                        RealT=Float32)
+                        l2=[0.036355633f0,
+                            0.042947736f0,
+                            0.042947732f0,
+                            0.025748007f0,
+                            0.16211234f0,
+                            0.017452473f0,
+                            0.017452475f0,
+                            0.026877586,
+                            2.4459175f-7],
+                        linf=[0.22100985f0,
+                            0.28798956f0,
+                            0.28799006f0,
+                            0.20858262f0,
+                            0.88126993f0,
+                            0.09208238f0,
+                            0.092081904f0,
+                            0.092081904f0,
+                            0.14795405f0,
+                            2.2979193f-6],
+                        RealT_for_test_tolerances=Float32)
     # Ensure that we do not have excessive memory allocations
     # (e.g., from type instabilities)
     @test_allocations(Trixi.rhs!, semi, sol, 1000)
@@ -402,7 +403,7 @@ end
                         # 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 
+                        # 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.
                         surface_flux=(FluxLaxFriedrichs(max_abs_speed_naive),
                                       flux_nonconservative_powell_local_jump),