From e2e2c20fdd4f60e5218d56a613ca9cfcd90b60e5 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Tue, 10 Dec 2024 13:34:03 +0100 Subject: [PATCH 01/40] adding flexibility to noncons BCs --- src/equations/shallow_water_1d.jl | 10 ++++++++-- src/equations/shallow_water_2d.jl | 18 +++++++++++++----- src/solvers/dgsem_p4est/dg_2d.jl | 12 +++--------- src/solvers/dgsem_tree/dg_1d.jl | 10 +++------- src/solvers/dgsem_tree/dg_2d.jl | 9 ++------- src/solvers/dgsem_unstructured/dg_2d.jl | 9 ++------- 6 files changed, 31 insertions(+), 37 deletions(-) diff --git a/src/equations/shallow_water_1d.jl b/src/equations/shallow_water_1d.jl index 29642470262..f308aa32f9f 100644 --- a/src/equations/shallow_water_1d.jl +++ b/src/equations/shallow_water_1d.jl @@ -160,9 +160,11 @@ For details see Section 9.2.5 of the book: """ @inline function boundary_condition_slip_wall(u_inner, orientation_or_normal, direction, x, t, - surface_flux_function, + surface_flux_functions, equations::ShallowWaterEquations1D) + # The boundary conditions for the non-conservative term are identically 0 here. + surface_flux_function, nonconservative_flux_function = surface_flux_functions # create the "external" boundary solution state u_boundary = SVector(u_inner[1], -u_inner[2], @@ -172,12 +174,16 @@ For details see Section 9.2.5 of the book: if iseven(direction) # u_inner is "left" of boundary, u_boundary is "right" of boundary flux = surface_flux_function(u_inner, u_boundary, orientation_or_normal, equations) + noncons = nonconservative_flux_function(u_inner, u_boundary, orientation_or_normal, + equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation_or_normal, equations) + noncons = surface_flux_function(u_boundary, u_inner, orientation_or_normal, + equations) end - return flux + return flux + 0.5f0 * noncons end # Calculate 1D flux for a single point diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index 510d4560f9b..15a989b4e1d 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -180,8 +180,11 @@ For details see Section 9.2.5 of the book: """ @inline function boundary_condition_slip_wall(u_inner, normal_direction::AbstractVector, x, t, - surface_flux_function, + surface_flux_functions, equations::ShallowWaterEquations2D) + + surface_flux_function, nonconservative_flux_function = surface_flux_functions + # normalize the outward pointing direction normal = normal_direction / norm(normal_direction) @@ -196,8 +199,9 @@ For details see Section 9.2.5 of the book: # calculate the boundary flux flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) - - return flux + noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, equations) + + return flux + 0.5f0 * noncons end """ @@ -208,8 +212,10 @@ Should be used together with [`TreeMesh`](@ref). """ @inline function boundary_condition_slip_wall(u_inner, orientation, direction, x, t, - surface_flux_function, + surface_flux_functions, equations::ShallowWaterEquations2D) + # The boundary conditions for the non-conservative term are identically 0 here. + surface_flux_function, nonconservative_flux_function = surface_flux_functions ## get the appropriate normal vector from the orientation if orientation == 1 u_boundary = SVector(u_inner[1], -u_inner[2], u_inner[3], u_inner[4]) @@ -220,11 +226,13 @@ Should be used together with [`TreeMesh`](@ref). # Calculate boundary flux if iseven(direction) # u_inner is "left" of boundary, u_boundary is "right" of boundary flux = surface_flux_function(u_inner, u_boundary, orientation, equations) + noncons = nonconservative_flux_function(u_inner, u_boundary, orientation, equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation, equations) + noncons = nonconservative_flux_function(u_boundary, u_inner, orientation, equations) end - return flux + return flux + 0.5f0 * noncons end # Calculate 1D flux for a single point diff --git a/src/solvers/dgsem_p4est/dg_2d.jl b/src/solvers/dgsem_p4est/dg_2d.jl index 6a7bbbb71d7..1f824b82026 100644 --- a/src/solvers/dgsem_p4est/dg_2d.jl +++ b/src/solvers/dgsem_p4est/dg_2d.jl @@ -349,7 +349,7 @@ end boundary_index) @unpack boundaries = cache @unpack node_coordinates, contravariant_vectors = cache.elements - surface_flux, nonconservative_flux = surface_integral.surface_flux + # Extract solution data from boundary container u_inner = get_node_vars(boundaries.u, equations, dg, node_index, boundary_index) @@ -364,20 +364,14 @@ end # Call pointwise numerical flux function for the conservative part # in the normal direction on the boundary - flux_ = boundary_condition(u_inner, normal_direction, x, t, surface_flux, equations) - - # Compute pointwise nonconservative numerical flux at the boundary. - noncons_ = boundary_condition(u_inner, normal_direction, x, t, nonconservative_flux, - equations) + flux_ = boundary_condition(u_inner, normal_direction, x, t, surface_integral.surface_flux, equations) # Copy flux to element storage in the correct orientation for v in eachvariable(equations) # Note the factor 0.5 necessary for the nonconservative fluxes based on # the interpretation of global SBP operators coupled discontinuously via # central fluxes/SATs - surface_flux_values[v, node_index, direction_index, element_index] = flux_[v] + - 0.5f0 * - noncons_[v] + surface_flux_values[v, node_index, direction_index, element_index] = flux_[v] end end diff --git a/src/solvers/dgsem_tree/dg_1d.jl b/src/solvers/dgsem_tree/dg_1d.jl index b5a67027541..df781a488f7 100644 --- a/src/solvers/dgsem_tree/dg_1d.jl +++ b/src/solvers/dgsem_tree/dg_1d.jl @@ -564,7 +564,6 @@ function calc_boundary_flux_by_direction!(surface_flux_values::AbstractArray{<:A nonconservative_terms::True, equations, surface_integral, dg::DG, cache, direction, first_boundary, last_boundary) - surface_flux, nonconservative_flux = surface_integral.surface_flux @unpack u, neighbor_ids, neighbor_sides, node_coordinates, orientations = cache.boundaries @threaded for boundary in first_boundary:last_boundary @@ -579,17 +578,14 @@ function calc_boundary_flux_by_direction!(surface_flux_values::AbstractArray{<:A u_inner = u_rr end x = get_node_coords(node_coordinates, equations, dg, boundary) + flux = boundary_condition(u_inner, orientations[boundary], direction, x, t, - surface_flux, + surface_integral.surface_flux, equations) - noncons_flux = boundary_condition(u_inner, orientations[boundary], direction, x, - t, nonconservative_flux, - equations) # Copy flux to left and right element storage for v in eachvariable(equations) - surface_flux_values[v, direction, neighbor] = flux[v] + - 0.5f0 * noncons_flux[v] + surface_flux_values[v, direction, neighbor] = flux[v] end end diff --git a/src/solvers/dgsem_tree/dg_2d.jl b/src/solvers/dgsem_tree/dg_2d.jl index 98bd0889206..0fc36f377c3 100644 --- a/src/solvers/dgsem_tree/dg_2d.jl +++ b/src/solvers/dgsem_tree/dg_2d.jl @@ -762,7 +762,6 @@ function calc_boundary_flux_by_direction!(surface_flux_values::AbstractArray{<:A nonconservative_terms::True, equations, surface_integral, dg::DG, cache, direction, first_boundary, last_boundary) - surface_flux, nonconservative_flux = surface_integral.surface_flux @unpack u, neighbor_ids, neighbor_sides, node_coordinates, orientations = cache.boundaries @threaded for boundary in first_boundary:last_boundary @@ -779,16 +778,12 @@ function calc_boundary_flux_by_direction!(surface_flux_values::AbstractArray{<:A end x = get_node_coords(node_coordinates, equations, dg, i, boundary) flux = boundary_condition(u_inner, orientations[boundary], direction, x, t, - surface_flux, + surface_integral.surface_flux, equations) - noncons_flux = boundary_condition(u_inner, orientations[boundary], - direction, x, t, nonconservative_flux, - equations) # Copy flux to left and right element storage for v in eachvariable(equations) - surface_flux_values[v, i, direction, neighbor] = flux[v] + - 0.5f0 * noncons_flux[v] + surface_flux_values[v, i, direction, neighbor] = flux[v] end end end diff --git a/src/solvers/dgsem_unstructured/dg_2d.jl b/src/solvers/dgsem_unstructured/dg_2d.jl index 48d4fe153c6..7b32f000515 100644 --- a/src/solvers/dgsem_unstructured/dg_2d.jl +++ b/src/solvers/dgsem_unstructured/dg_2d.jl @@ -426,7 +426,6 @@ end surface_integral, dg::DG, cache, node_index, side_index, element_index, boundary_index) - surface_flux, nonconservative_flux = surface_integral.surface_flux @unpack normal_directions = cache.elements @unpack u, node_coordinates = cache.boundaries @@ -442,19 +441,15 @@ end # Call pointwise numerical flux function for the conservative part # in the normal direction on the boundary - flux = boundary_condition(u_inner, outward_direction, x, t, surface_flux, equations) + flux = boundary_condition(u_inner, outward_direction, x, t, surface_integral.surface_flux, equations) # Compute pointwise nonconservative numerical flux at the boundary. - noncons_flux = boundary_condition(u_inner, outward_direction, x, t, - nonconservative_flux, equations) for v in eachvariable(equations) # Note the factor 0.5 necessary for the nonconservative fluxes based on # the interpretation of global SBP operators coupled discontinuously via # central fluxes/SATs - surface_flux_values[v, node_index, side_index, element_index] = flux[v] + - 0.5f0 * - noncons_flux[v] + surface_flux_values[v, node_index, side_index, element_index] = flux[v] end end From 1e925fc780d15cc02956d79fdf451c941dc83507 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Tue, 10 Dec 2024 13:36:24 +0100 Subject: [PATCH 02/40] minor fix --- src/equations/shallow_water_1d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/shallow_water_1d.jl b/src/equations/shallow_water_1d.jl index f308aa32f9f..b761ad0e50c 100644 --- a/src/equations/shallow_water_1d.jl +++ b/src/equations/shallow_water_1d.jl @@ -179,7 +179,7 @@ For details see Section 9.2.5 of the book: else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation_or_normal, equations) - noncons = surface_flux_function(u_boundary, u_inner, orientation_or_normal, + noncons = nonconservative_flux_function(u_boundary, u_inner, orientation_or_normal, equations) end From 31f1e0a26cb446458e29d5c26c4611805d0f2e89 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Tue, 10 Dec 2024 14:09:37 +0100 Subject: [PATCH 03/40] Dirichlet BC for noncons --- .../dgmulti_2d/elixir_mhd_reflective_wall.jl | 9 +++++---- src/equations/equations.jl | 18 ++++++++++++++++++ 2 files changed, 23 insertions(+), 4 deletions(-) diff --git a/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl b/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl index 11670288526..9491af3f510 100644 --- a/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl +++ b/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl @@ -49,9 +49,9 @@ mesh = DGMultiMesh(solver, cells_per_dimension; periodicity = (false, false), # Create a "reflective-like" boundary condition by mirroring the velocity but leaving the magnetic field alone. # Note that this boundary condition is probably not entropy stable. function boundary_condition_velocity_slip_wall(u_inner, normal_direction::AbstractVector, - x, t, surface_flux_function, + x, t, surface_flux_functions, equations::IdealGlmMhdEquations2D) - + surface_flux_function, nonconservative_flux_function = surface_flux_functions # Normalize the vector without using `normalize` since we need to multiply by the `norm_` later norm_ = norm(normal_direction) normal = normal_direction / norm_ @@ -63,8 +63,9 @@ function boundary_condition_velocity_slip_wall(u_inner, normal_direction::Abstra u_mirror = prim2cons(SVector(rho, v1 - 2 * v_normal * normal[1], v2 - 2 * v_normal * normal[2], v3, p, B1, B2, B3, psi), equations) - - return surface_flux_function(u_inner, u_mirror, normal, equations) * norm_ + flux = surface_flux_function(u_inner, u_mirror, normal, equations) * norm_ + noncons = nonconservative_flux_function(u_inner, u_mirror, normal, equations) * norm_ + return flux + 0.5f0 * noncons end boundary_conditions = (; x_neg = boundary_condition_velocity_slip_wall, diff --git a/src/equations/equations.jl b/src/equations/equations.jl index 0304ea16cfe..41287492c37 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -200,6 +200,24 @@ end return flux end +# Dirichlet-type boundary condition for equations with non-conservative terms for use with UnstructuredMesh2D +# Note: For unstructured we lose the concept of an "absolute direction" +@inline function (boundary_condition::BoundaryConditionDirichlet)(u_inner, + normal_direction::AbstractVector, + x, t, + surface_flux_functions::Tuple, + equations) + surface_flux_function, nonconservative_flux_function = surface_flux_functions + +# get the external value of the solution +u_boundary = boundary_condition.boundary_value_function(x, t, equations) + +# Calculate boundary flux +flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) +noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, equations) +return flux + 0.5f0 * noncons +end + # operator types used for dispatch on parabolic boundary fluxes struct Gradient end struct Divergence end From eb1ccdd152472fdbcadc626925601b13905a4536 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Tue, 10 Dec 2024 14:21:33 +0100 Subject: [PATCH 04/40] formatting --- src/equations/equations.jl | 21 +++++++++++---------- src/equations/shallow_water_1d.jl | 10 ++++++---- src/equations/shallow_water_2d.jl | 16 +++++++++------- src/solvers/dgsem_p4est/dg_2d.jl | 4 ++-- src/solvers/dgsem_tree/dg_1d.jl | 2 +- src/solvers/dgsem_tree/dg_2d.jl | 2 +- src/solvers/dgsem_unstructured/dg_2d.jl | 3 ++- 7 files changed, 32 insertions(+), 26 deletions(-) diff --git a/src/equations/equations.jl b/src/equations/equations.jl index 41287492c37..bd28c482f59 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -203,19 +203,20 @@ end # Dirichlet-type boundary condition for equations with non-conservative terms for use with UnstructuredMesh2D # Note: For unstructured we lose the concept of an "absolute direction" @inline function (boundary_condition::BoundaryConditionDirichlet)(u_inner, - normal_direction::AbstractVector, - x, t, - surface_flux_functions::Tuple, - equations) + normal_direction::AbstractVector, + x, t, + surface_flux_functions::Tuple, + equations) surface_flux_function, nonconservative_flux_function = surface_flux_functions -# get the external value of the solution -u_boundary = boundary_condition.boundary_value_function(x, t, equations) + # get the external value of the solution + u_boundary = boundary_condition.boundary_value_function(x, t, equations) -# Calculate boundary flux -flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) -noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, equations) -return flux + 0.5f0 * noncons + # Calculate boundary flux + flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) + noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, + equations) + return flux + 0.5f0 * noncons end # operator types used for dispatch on parabolic boundary fluxes diff --git a/src/equations/shallow_water_1d.jl b/src/equations/shallow_water_1d.jl index b761ad0e50c..3d3cdfa8538 100644 --- a/src/equations/shallow_water_1d.jl +++ b/src/equations/shallow_water_1d.jl @@ -174,13 +174,15 @@ For details see Section 9.2.5 of the book: if iseven(direction) # u_inner is "left" of boundary, u_boundary is "right" of boundary flux = surface_flux_function(u_inner, u_boundary, orientation_or_normal, equations) - noncons = nonconservative_flux_function(u_inner, u_boundary, orientation_or_normal, - equations) + noncons = nonconservative_flux_function(u_inner, u_boundary, + orientation_or_normal, + equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation_or_normal, equations) - noncons = nonconservative_flux_function(u_boundary, u_inner, orientation_or_normal, - equations) + noncons = nonconservative_flux_function(u_boundary, u_inner, + orientation_or_normal, + equations) end return flux + 0.5f0 * noncons diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index 15a989b4e1d..eb5ebac0028 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -182,9 +182,8 @@ For details see Section 9.2.5 of the book: x, t, surface_flux_functions, equations::ShallowWaterEquations2D) - surface_flux_function, nonconservative_flux_function = surface_flux_functions - + # normalize the outward pointing direction normal = normal_direction / norm(normal_direction) @@ -199,8 +198,9 @@ For details see Section 9.2.5 of the book: # calculate the boundary flux flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) - noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, equations) - + noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, + equations) + return flux + 0.5f0 * noncons end @@ -214,7 +214,7 @@ Should be used together with [`TreeMesh`](@ref). direction, x, t, surface_flux_functions, equations::ShallowWaterEquations2D) - # The boundary conditions for the non-conservative term are identically 0 here. + # The boundary conditions for the non-conservative term are identically 0 here. surface_flux_function, nonconservative_flux_function = surface_flux_functions ## get the appropriate normal vector from the orientation if orientation == 1 @@ -226,10 +226,12 @@ Should be used together with [`TreeMesh`](@ref). # Calculate boundary flux if iseven(direction) # u_inner is "left" of boundary, u_boundary is "right" of boundary flux = surface_flux_function(u_inner, u_boundary, orientation, equations) - noncons = nonconservative_flux_function(u_inner, u_boundary, orientation, equations) + noncons = nonconservative_flux_function(u_inner, u_boundary, orientation, + equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation, equations) - noncons = nonconservative_flux_function(u_boundary, u_inner, orientation, equations) + noncons = nonconservative_flux_function(u_boundary, u_inner, orientation, + equations) end return flux + 0.5f0 * noncons diff --git a/src/solvers/dgsem_p4est/dg_2d.jl b/src/solvers/dgsem_p4est/dg_2d.jl index 1f824b82026..652b172f5d3 100644 --- a/src/solvers/dgsem_p4est/dg_2d.jl +++ b/src/solvers/dgsem_p4est/dg_2d.jl @@ -349,7 +349,6 @@ end boundary_index) @unpack boundaries = cache @unpack node_coordinates, contravariant_vectors = cache.elements - # Extract solution data from boundary container u_inner = get_node_vars(boundaries.u, equations, dg, node_index, boundary_index) @@ -364,7 +363,8 @@ end # Call pointwise numerical flux function for the conservative part # in the normal direction on the boundary - flux_ = boundary_condition(u_inner, normal_direction, x, t, surface_integral.surface_flux, equations) + flux_ = boundary_condition(u_inner, normal_direction, x, t, + surface_integral.surface_flux, equations) # Copy flux to element storage in the correct orientation for v in eachvariable(equations) diff --git a/src/solvers/dgsem_tree/dg_1d.jl b/src/solvers/dgsem_tree/dg_1d.jl index df781a488f7..3de64a28987 100644 --- a/src/solvers/dgsem_tree/dg_1d.jl +++ b/src/solvers/dgsem_tree/dg_1d.jl @@ -578,7 +578,7 @@ function calc_boundary_flux_by_direction!(surface_flux_values::AbstractArray{<:A u_inner = u_rr end x = get_node_coords(node_coordinates, equations, dg, boundary) - + flux = boundary_condition(u_inner, orientations[boundary], direction, x, t, surface_integral.surface_flux, equations) diff --git a/src/solvers/dgsem_tree/dg_2d.jl b/src/solvers/dgsem_tree/dg_2d.jl index 0fc36f377c3..3917d1eeb4f 100644 --- a/src/solvers/dgsem_tree/dg_2d.jl +++ b/src/solvers/dgsem_tree/dg_2d.jl @@ -778,7 +778,7 @@ function calc_boundary_flux_by_direction!(surface_flux_values::AbstractArray{<:A end x = get_node_coords(node_coordinates, equations, dg, i, boundary) flux = boundary_condition(u_inner, orientations[boundary], direction, x, t, - surface_integral.surface_flux, + surface_integral.surface_flux, equations) # Copy flux to left and right element storage diff --git a/src/solvers/dgsem_unstructured/dg_2d.jl b/src/solvers/dgsem_unstructured/dg_2d.jl index 7b32f000515..ec6b78bbca0 100644 --- a/src/solvers/dgsem_unstructured/dg_2d.jl +++ b/src/solvers/dgsem_unstructured/dg_2d.jl @@ -441,7 +441,8 @@ end # Call pointwise numerical flux function for the conservative part # in the normal direction on the boundary - flux = boundary_condition(u_inner, outward_direction, x, t, surface_integral.surface_flux, equations) + flux = boundary_condition(u_inner, outward_direction, x, t, + surface_integral.surface_flux, equations) # Compute pointwise nonconservative numerical flux at the boundary. From e4bc1819df501d25801ae995a7468377594fe5cd Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Tue, 10 Dec 2024 17:45:49 +0100 Subject: [PATCH 05/40] Noncons Dirichlet BC --- src/equations/equations.jl | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) diff --git a/src/equations/equations.jl b/src/equations/equations.jl index bd28c482f59..fb7e50e45a9 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -184,6 +184,35 @@ end return flux end +# Dirichlet-type boundary condition for use with TreeMesh or StructuredMesh +@inline function (boundary_condition::BoundaryConditionDirichlet)(u_inner, + orientation_or_normal, + direction, + x, t, + surface_flux_functions::Tuple, + equations) + surface_flux_function, nonconservative_flux_function = surface_flux_functions + + u_boundary = boundary_condition.boundary_value_function(x, t, equations) + + # Calculate boundary flux + if iseven(direction) # u_inner is "left" of boundary, u_boundary is "right" of boundary + flux = surface_flux_function(u_inner, u_boundary, orientation_or_normal, + equations) + noncons = nonconservative_flux_function(u_inner, u_boundary, + orientation_or_normal, + equations) + else # u_boundary is "left" of boundary, u_inner is "right" of boundary + flux = surface_flux_function(u_boundary, u_inner, orientation_or_normal, + equations) + noncons = nonconservative_flux_function(u_boundary, u_inner, + orientation_or_normal, + equations) + end + + return flux + 0.5f0 * noncons +end + # Dirichlet-type boundary condition for use with UnstructuredMesh2D # Note: For unstructured we lose the concept of an "absolute direction" @inline function (boundary_condition::BoundaryConditionDirichlet)(u_inner, From 8c5d2fc04216c945adbb839ef75a75aaeb7eb575 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Tue, 10 Dec 2024 18:55:27 +0100 Subject: [PATCH 06/40] test_type.jl fix --- test/test_type.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/test_type.jl b/test/test_type.jl index 92274bf4248..51f30b0bc9d 100644 --- a/test/test_type.jl +++ b/test/test_type.jl @@ -2150,7 +2150,7 @@ isdir(outdir) && rm(outdir, recursive = true) directions = [1, 2] normal_direction = SVector(one(RealT)) - surface_flux_function = flux_lax_friedrichs + surface_flux_function = (flux_lax_friedrichs, flux_lax_friedrichs) dissipation = DissipationLocalLaxFriedrichs() numflux = FluxHLL() @@ -2239,7 +2239,7 @@ isdir(outdir) && rm(outdir, recursive = true) directions = [1, 2, 3, 4] normal_direction = SVector(one(RealT), zero(RealT)) - surface_flux_function = flux_lax_friedrichs + surface_flux_function = (flux_lax_friedrichs, flux_lax_friedrichs) dissipation = DissipationLocalLaxFriedrichs() numflux = FluxHLL() From c2b44ae97088ae33c2e414ad2338ab8ce9389c41 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Tue, 10 Dec 2024 22:40:27 +0100 Subject: [PATCH 07/40] dg multi fix --- src/basic_types.jl | 24 ++++++++++++++++++++++++ src/solvers/dgmulti/dg.jl | 17 ++++------------- 2 files changed, 28 insertions(+), 13 deletions(-) diff --git a/src/basic_types.jl b/src/basic_types.jl index 8a2430c1a85..a64d803df18 100644 --- a/src/basic_types.jl +++ b/src/basic_types.jl @@ -74,6 +74,19 @@ struct BoundaryConditionDoNothing end return surface_flux(u_inner, u_inner, orientation_or_normal_direction, equations) end +# This version can be called by hyperbolic solvers on logically Cartesian meshes +@inline function (::BoundaryConditionDoNothing)(u_inner, + orientation_or_normal_direction, + direction::Integer, x, t, + surface_flux_functions::Tuple, + equations) + surface_flux_function, nonconservative_flux_function = surface_flux_functions + return surface_flux_function(u_inner, u_inner, orientation_or_normal_direction, + equations) + + 0.5f0 * nonconservative_flux_function(u_inner, u_inner, + orientation_or_normal_direction, equations) +end + # This version can be called by hyperbolic solvers on unstructured, curved meshes @inline function (::BoundaryConditionDoNothing)(u_inner, outward_direction::AbstractVector, @@ -81,6 +94,17 @@ end return surface_flux(u_inner, u_inner, outward_direction, equations) end +@inline function (::BoundaryConditionDoNothing)(u_inner, + outward_direction::AbstractVector, + x, t, surface_flux_functions::Tuple, + equations) + surface_flux_function, nonconservative_flux_function = surface_flux_functions + + return surface_flux_function(u_inner, u_inner, outward_direction, equations) + + 0.5f0 * + nonconservative_flux_function(u_inner, u_inner, outward_direction, equations) +end + # This version can be called by parabolic solvers @inline function (::BoundaryConditionDoNothing)(inner_flux_or_state, other_args...) return inner_flux_or_state diff --git a/src/solvers/dgmulti/dg.jl b/src/solvers/dgmulti/dg.jl index 2d588c5c79d..ea7b83e2f70 100644 --- a/src/solvers/dgmulti/dg.jl +++ b/src/solvers/dgmulti/dg.jl @@ -519,7 +519,6 @@ function calc_single_boundary_flux!(cache, t, boundary_condition, boundary_key, dg::DGMulti{NDIMS}) where {NDIMS} rd = dg.basis md = mesh.md - surface_flux, nonconservative_flux = dg.surface_integral.surface_flux # reshape face/normal arrays to have size = (num_points_on_face, num_faces_total). # mesh.boundary_faces indexes into the columns of these face-reshaped arrays. @@ -549,18 +548,10 @@ function calc_single_boundary_flux!(cache, t, boundary_condition, boundary_key, cons_flux_at_face_node = boundary_condition(u_face_values[i, f], face_normal, face_coordinates, t, - surface_flux, equations) - - # Compute pointwise nonconservative numerical flux at the boundary. - noncons_flux_at_face_node = boundary_condition(u_face_values[i, f], - face_normal, - face_coordinates, - t, - nonconservative_flux, - equations) - - flux_face_values[i, f] = (cons_flux_at_face_node + - 0.5 * noncons_flux_at_face_node) * Jf[i, f] + dg.surface_integral.surface_flux, + equations) + + flux_face_values[i, f] = (cons_flux_at_face_node) * Jf[i, f] end end From b60eaf19676726ead47f20ba6edf027b6c62ce1b Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Tue, 7 Jan 2025 10:03:36 +0100 Subject: [PATCH 08/40] moving 0.5 factor internally --- .../dgmulti_2d/elixir_mhd_reflective_wall.jl | 2 +- src/basic_types.jl | 10 +++++----- src/equations/equations.jl | 4 ++-- src/equations/shallow_water_1d.jl | 2 +- src/equations/shallow_water_2d.jl | 4 ++-- src/solvers/dgmulti/dg.jl | 17 ++++++++++------- src/solvers/dgsem_p4est/dg_2d.jl | 8 +++++--- src/solvers/dgsem_tree/dg_1d.jl | 10 ++++++---- src/solvers/dgsem_tree/dg_2d.jl | 10 ++++++---- src/solvers/dgsem_unstructured/dg_2d.jl | 8 +++++--- 10 files changed, 43 insertions(+), 32 deletions(-) diff --git a/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl b/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl index 9491af3f510..5ba3a2d85cd 100644 --- a/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl +++ b/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl @@ -65,7 +65,7 @@ function boundary_condition_velocity_slip_wall(u_inner, normal_direction::Abstra v3, p, B1, B2, B3, psi), equations) flux = surface_flux_function(u_inner, u_mirror, normal, equations) * norm_ noncons = nonconservative_flux_function(u_inner, u_mirror, normal, equations) * norm_ - return flux + 0.5f0 * noncons + return flux, noncons end boundary_conditions = (; x_neg = boundary_condition_velocity_slip_wall, diff --git a/src/basic_types.jl b/src/basic_types.jl index a64d803df18..891f815db32 100644 --- a/src/basic_types.jl +++ b/src/basic_types.jl @@ -82,8 +82,8 @@ end equations) surface_flux_function, nonconservative_flux_function = surface_flux_functions return surface_flux_function(u_inner, u_inner, orientation_or_normal_direction, - equations) + - 0.5f0 * nonconservative_flux_function(u_inner, u_inner, + equations), + nonconservative_flux_function(u_inner, u_inner, orientation_or_normal_direction, equations) end @@ -100,9 +100,9 @@ end equations) surface_flux_function, nonconservative_flux_function = surface_flux_functions - return surface_flux_function(u_inner, u_inner, outward_direction, equations) + - 0.5f0 * - nonconservative_flux_function(u_inner, u_inner, outward_direction, equations) + return surface_flux_function(u_inner, u_inner, outward_direction, equations), + nonconservative_flux_function(u_inner, u_inner, outward_direction, + equations) end # This version can be called by parabolic solvers diff --git a/src/equations/equations.jl b/src/equations/equations.jl index fb7e50e45a9..d8b5fb39a55 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -210,7 +210,7 @@ end equations) end - return flux + 0.5f0 * noncons + return flux, noncons end # Dirichlet-type boundary condition for use with UnstructuredMesh2D @@ -245,7 +245,7 @@ end flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, equations) - return flux + 0.5f0 * noncons + return flux, noncons end # operator types used for dispatch on parabolic boundary fluxes diff --git a/src/equations/shallow_water_1d.jl b/src/equations/shallow_water_1d.jl index 3d3cdfa8538..14f372ce5a3 100644 --- a/src/equations/shallow_water_1d.jl +++ b/src/equations/shallow_water_1d.jl @@ -185,7 +185,7 @@ For details see Section 9.2.5 of the book: equations) end - return flux + 0.5f0 * noncons + return flux, noncons end # Calculate 1D flux for a single point diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index eb5ebac0028..310a5a8e6f9 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -201,7 +201,7 @@ For details see Section 9.2.5 of the book: noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, equations) - return flux + 0.5f0 * noncons + return flux, noncons end """ @@ -234,7 +234,7 @@ Should be used together with [`TreeMesh`](@ref). equations) end - return flux + 0.5f0 * noncons + return flux, noncons end # Calculate 1D flux for a single point diff --git a/src/solvers/dgmulti/dg.jl b/src/solvers/dgmulti/dg.jl index ea7b83e2f70..75b8978abcc 100644 --- a/src/solvers/dgmulti/dg.jl +++ b/src/solvers/dgmulti/dg.jl @@ -545,13 +545,16 @@ function calc_single_boundary_flux!(cache, t, boundary_condition, boundary_key, # Compute conservative and non-conservative fluxes separately. # This imposes boundary conditions on the conservative part of the flux. - cons_flux_at_face_node = boundary_condition(u_face_values[i, f], - face_normal, face_coordinates, - t, - dg.surface_integral.surface_flux, - equations) - - flux_face_values[i, f] = (cons_flux_at_face_node) * Jf[i, f] + cons_flux_at_face_node, noncons_flux_at_face_node = boundary_condition(u_face_values[i, + f], + face_normal, + face_coordinates, + t, + dg.surface_integral.surface_flux, + equations) + + flux_face_values[i, f] = (cons_flux_at_face_node + + 0.5f0 * noncons_flux_at_face_node) * Jf[i, f] end end diff --git a/src/solvers/dgsem_p4est/dg_2d.jl b/src/solvers/dgsem_p4est/dg_2d.jl index 652b172f5d3..32d155427a6 100644 --- a/src/solvers/dgsem_p4est/dg_2d.jl +++ b/src/solvers/dgsem_p4est/dg_2d.jl @@ -363,15 +363,17 @@ end # Call pointwise numerical flux function for the conservative part # in the normal direction on the boundary - flux_ = boundary_condition(u_inner, normal_direction, x, t, - surface_integral.surface_flux, equations) + flux_, noncons_ = boundary_condition(u_inner, normal_direction, x, t, + surface_integral.surface_flux, equations) # Copy flux to element storage in the correct orientation for v in eachvariable(equations) # Note the factor 0.5 necessary for the nonconservative fluxes based on # the interpretation of global SBP operators coupled discontinuously via # central fluxes/SATs - surface_flux_values[v, node_index, direction_index, element_index] = flux_[v] + surface_flux_values[v, node_index, direction_index, element_index] = flux_[v] + + 0.5f0 * + noncons_[v] end end diff --git a/src/solvers/dgsem_tree/dg_1d.jl b/src/solvers/dgsem_tree/dg_1d.jl index 3de64a28987..62c71177f37 100644 --- a/src/solvers/dgsem_tree/dg_1d.jl +++ b/src/solvers/dgsem_tree/dg_1d.jl @@ -579,13 +579,15 @@ function calc_boundary_flux_by_direction!(surface_flux_values::AbstractArray{<:A end x = get_node_coords(node_coordinates, equations, dg, boundary) - flux = boundary_condition(u_inner, orientations[boundary], direction, x, t, - surface_integral.surface_flux, - equations) + flux, noncons_flux = boundary_condition(u_inner, orientations[boundary], + direction, x, t, + surface_integral.surface_flux, + equations) # Copy flux to left and right element storage for v in eachvariable(equations) - surface_flux_values[v, direction, neighbor] = flux[v] + surface_flux_values[v, direction, neighbor] = flux[v] + + 0.5f0 * noncons_flux[v] end end diff --git a/src/solvers/dgsem_tree/dg_2d.jl b/src/solvers/dgsem_tree/dg_2d.jl index 3917d1eeb4f..a79584df48d 100644 --- a/src/solvers/dgsem_tree/dg_2d.jl +++ b/src/solvers/dgsem_tree/dg_2d.jl @@ -777,13 +777,15 @@ function calc_boundary_flux_by_direction!(surface_flux_values::AbstractArray{<:A u_inner = u_rr end x = get_node_coords(node_coordinates, equations, dg, i, boundary) - flux = boundary_condition(u_inner, orientations[boundary], direction, x, t, - surface_integral.surface_flux, - equations) + flux, noncons_flux = boundary_condition(u_inner, orientations[boundary], + direction, x, t, + surface_integral.surface_flux, + equations) # Copy flux to left and right element storage for v in eachvariable(equations) - surface_flux_values[v, i, direction, neighbor] = flux[v] + surface_flux_values[v, i, direction, neighbor] = flux[v] + + 0.5f0 * noncons_flux[v] end end end diff --git a/src/solvers/dgsem_unstructured/dg_2d.jl b/src/solvers/dgsem_unstructured/dg_2d.jl index ec6b78bbca0..34effb1f11f 100644 --- a/src/solvers/dgsem_unstructured/dg_2d.jl +++ b/src/solvers/dgsem_unstructured/dg_2d.jl @@ -441,8 +441,8 @@ end # Call pointwise numerical flux function for the conservative part # in the normal direction on the boundary - flux = boundary_condition(u_inner, outward_direction, x, t, - surface_integral.surface_flux, equations) + flux, noncons_flux = boundary_condition(u_inner, outward_direction, x, t, + surface_integral.surface_flux, equations) # Compute pointwise nonconservative numerical flux at the boundary. @@ -450,7 +450,9 @@ end # Note the factor 0.5 necessary for the nonconservative fluxes based on # the interpretation of global SBP operators coupled discontinuously via # central fluxes/SATs - surface_flux_values[v, node_index, side_index, element_index] = flux[v] + surface_flux_values[v, node_index, side_index, element_index] = flux[v] + + 0.5f0 * + noncons_flux[v] end end From 840fa9e69805960ead603bbe3b8d69a759120530 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:48:04 +0100 Subject: [PATCH 09/40] Update src/solvers/dgsem_p4est/dg_2d.jl Co-authored-by: Daniel Doehring --- src/solvers/dgsem_p4est/dg_2d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/solvers/dgsem_p4est/dg_2d.jl b/src/solvers/dgsem_p4est/dg_2d.jl index 32d155427a6..9931b31fa84 100644 --- a/src/solvers/dgsem_p4est/dg_2d.jl +++ b/src/solvers/dgsem_p4est/dg_2d.jl @@ -363,7 +363,7 @@ end # Call pointwise numerical flux function for the conservative part # in the normal direction on the boundary - flux_, noncons_ = boundary_condition(u_inner, normal_direction, x, t, + flux, noncons_flux = boundary_condition(u_inner, normal_direction, x, t, surface_integral.surface_flux, equations) # Copy flux to element storage in the correct orientation From 2baa52a51e2f8f727bcbeda9465d69d87ae0be1c Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:48:11 +0100 Subject: [PATCH 10/40] Update src/equations/shallow_water_2d.jl Co-authored-by: Daniel Doehring --- src/equations/shallow_water_2d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index 1e91270090e..4abf107d4fc 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -230,7 +230,7 @@ Should be used together with [`TreeMesh`](@ref). equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation, equations) - noncons = nonconservative_flux_function(u_boundary, u_inner, orientation, + noncons_flux = nonconservative_flux_function(u_boundary, u_inner, orientation, equations) end From cd2186b092c13122008667c83c16febf97fd7f81 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:48:17 +0100 Subject: [PATCH 11/40] Update src/equations/shallow_water_2d.jl Co-authored-by: Daniel Doehring --- src/equations/shallow_water_2d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index 4abf107d4fc..269b23e2f97 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -201,7 +201,7 @@ For details see Section 9.2.5 of the book: noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, equations) - return flux, noncons + return flux, noncons_flux end """ From 7a326fef9b260069d2e6944b6ade54f248cf0a1c Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:48:23 +0100 Subject: [PATCH 12/40] Update src/equations/equations.jl Co-authored-by: Daniel Doehring --- src/equations/equations.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/equations.jl b/src/equations/equations.jl index fc7ad482e5d..7e6a7208941 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -196,7 +196,7 @@ end if iseven(direction) # u_inner is "left" of boundary, u_boundary is "right" of boundary flux = surface_flux_function(u_inner, u_boundary, orientation_or_normal, equations) - noncons = nonconservative_flux_function(u_inner, u_boundary, + noncons_flux = nonconservative_flux_function(u_inner, u_boundary, orientation_or_normal, equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary From f9b19c3742e5acc4a52cd5617de569c273076d1a Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:48:28 +0100 Subject: [PATCH 13/40] Update examples/dgmulti_2d/elixir_mhd_reflective_wall.jl Co-authored-by: Daniel Doehring --- examples/dgmulti_2d/elixir_mhd_reflective_wall.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl b/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl index 5ba3a2d85cd..405a0f8398a 100644 --- a/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl +++ b/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl @@ -64,8 +64,8 @@ function boundary_condition_velocity_slip_wall(u_inner, normal_direction::Abstra v2 - 2 * v_normal * normal[2], v3, p, B1, B2, B3, psi), equations) flux = surface_flux_function(u_inner, u_mirror, normal, equations) * norm_ - noncons = nonconservative_flux_function(u_inner, u_mirror, normal, equations) * norm_ - return flux, noncons + noncons_flux = nonconservative_flux_function(u_inner, u_mirror, normal, equations) * norm_ + return flux, noncons_flux end boundary_conditions = (; x_neg = boundary_condition_velocity_slip_wall, From c35cff975142477d49bcbf5e8958924fbdea8b64 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:48:36 +0100 Subject: [PATCH 14/40] Update src/equations/shallow_water_2d.jl Co-authored-by: Daniel Doehring --- src/equations/shallow_water_2d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index 269b23e2f97..c3d17ccf766 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -234,7 +234,7 @@ Should be used together with [`TreeMesh`](@ref). equations) end - return flux, noncons + return flux, noncons_flux end # Calculate 1D flux for a single point From 26a756ad1e568b4b86abedf013284a76af90296e Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:48:44 +0100 Subject: [PATCH 15/40] Update src/equations/shallow_water_2d.jl Co-authored-by: Daniel Doehring --- src/equations/shallow_water_2d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index c3d17ccf766..2958c1b42c9 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -226,7 +226,7 @@ Should be used together with [`TreeMesh`](@ref). # Calculate boundary flux if iseven(direction) # u_inner is "left" of boundary, u_boundary is "right" of boundary flux = surface_flux_function(u_inner, u_boundary, orientation, equations) - noncons = nonconservative_flux_function(u_inner, u_boundary, orientation, + noncons_flux = nonconservative_flux_function(u_inner, u_boundary, orientation, equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation, equations) From 307197d6c6b341072e1db2f6ebf9a0f9133ceee9 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:48:56 +0100 Subject: [PATCH 16/40] Update src/equations/shallow_water_2d.jl Co-authored-by: Daniel Doehring --- src/equations/shallow_water_2d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index 2958c1b42c9..263460e3c53 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -198,7 +198,7 @@ For details see Section 9.2.5 of the book: # calculate the boundary flux flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) - noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, + noncons_flux = nonconservative_flux_function(u_inner, u_boundary, normal_direction, equations) return flux, noncons_flux From 8a1a3d50b19f7bdc2a4fd53ba2c577de3a2b61f5 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:49:08 +0100 Subject: [PATCH 17/40] Update src/equations/equations.jl Co-authored-by: Daniel Doehring --- src/equations/equations.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/equations.jl b/src/equations/equations.jl index 7e6a7208941..41d7b52215a 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -202,7 +202,7 @@ end else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation_or_normal, equations) - noncons = nonconservative_flux_function(u_boundary, u_inner, + noncons_flux = nonconservative_flux_function(u_boundary, u_inner, orientation_or_normal, equations) end From 506871731dd28acc956fbdd840586ebd5c864334 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:49:24 +0100 Subject: [PATCH 18/40] Update src/equations/equations.jl Co-authored-by: Daniel Doehring --- src/equations/equations.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/equations/equations.jl b/src/equations/equations.jl index 41d7b52215a..85cd5aa80fe 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -240,9 +240,9 @@ end # Calculate boundary flux flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) - noncons = nonconservative_flux_function(u_inner, u_boundary, normal_direction, + noncons_flux = nonconservative_flux_function(u_inner, u_boundary, normal_direction, equations) - return flux, noncons + return flux, noncons_flux end # operator types used for dispatch on parabolic boundary fluxes From 06b881e0f436b7d98119209564d61bb7837dc335 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:49:36 +0100 Subject: [PATCH 19/40] Update src/equations/equations.jl Co-authored-by: Daniel Doehring --- src/equations/equations.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/equations.jl b/src/equations/equations.jl index 85cd5aa80fe..2efee197bba 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -207,7 +207,7 @@ end equations) end - return flux, noncons + return flux, noncons_flux end # Dirichlet-type boundary condition for use with UnstructuredMesh2D From 4d112a443e163ed3576c1ce592eec7d7023626c6 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:49:48 +0100 Subject: [PATCH 20/40] Update src/equations/shallow_water_1d.jl Co-authored-by: Daniel Doehring --- src/equations/shallow_water_1d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/shallow_water_1d.jl b/src/equations/shallow_water_1d.jl index 62caf59e179..7ebeac6d615 100644 --- a/src/equations/shallow_water_1d.jl +++ b/src/equations/shallow_water_1d.jl @@ -174,7 +174,7 @@ For details see Section 9.2.5 of the book: if iseven(direction) # u_inner is "left" of boundary, u_boundary is "right" of boundary flux = surface_flux_function(u_inner, u_boundary, orientation_or_normal, equations) - noncons = nonconservative_flux_function(u_inner, u_boundary, + noncons_flux = nonconservative_flux_function(u_inner, u_boundary, orientation_or_normal, equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary From ecaf306f44b989b7bce14aad9912d02fbfe9e90e Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:49:57 +0100 Subject: [PATCH 21/40] Update src/equations/shallow_water_1d.jl Co-authored-by: Daniel Doehring --- src/equations/shallow_water_1d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/shallow_water_1d.jl b/src/equations/shallow_water_1d.jl index 7ebeac6d615..645a90c3ec8 100644 --- a/src/equations/shallow_water_1d.jl +++ b/src/equations/shallow_water_1d.jl @@ -180,7 +180,7 @@ For details see Section 9.2.5 of the book: else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation_or_normal, equations) - noncons = nonconservative_flux_function(u_boundary, u_inner, + noncons_flux = nonconservative_flux_function(u_boundary, u_inner, orientation_or_normal, equations) end From 1bd0184808ae3d0d363b3e55fd48b848e31bcc9d Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Wed, 8 Jan 2025 12:50:11 +0100 Subject: [PATCH 22/40] Update src/equations/shallow_water_1d.jl Co-authored-by: Daniel Doehring --- src/equations/shallow_water_1d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/equations/shallow_water_1d.jl b/src/equations/shallow_water_1d.jl index 645a90c3ec8..35834750080 100644 --- a/src/equations/shallow_water_1d.jl +++ b/src/equations/shallow_water_1d.jl @@ -185,7 +185,7 @@ For details see Section 9.2.5 of the book: equations) end - return flux, noncons + return flux, noncons_flux end # Calculate 1D flux for a single point From 51505aa396590f8ff54bc761a88b9e7f98085c2e Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Wed, 8 Jan 2025 13:34:47 +0100 Subject: [PATCH 23/40] minor fixes --- examples/dgmulti_2d/elixir_mhd_reflective_wall.jl | 3 ++- src/equations/equations.jl | 10 +++++----- src/equations/shallow_water_1d.jl | 8 ++++---- src/equations/shallow_water_2d.jl | 6 +++--- src/solvers/dgsem_p4est/dg_2d.jl | 6 +++--- 5 files changed, 17 insertions(+), 16 deletions(-) diff --git a/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl b/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl index 405a0f8398a..87f137917f6 100644 --- a/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl +++ b/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl @@ -64,7 +64,8 @@ function boundary_condition_velocity_slip_wall(u_inner, normal_direction::Abstra v2 - 2 * v_normal * normal[2], v3, p, B1, B2, B3, psi), equations) flux = surface_flux_function(u_inner, u_mirror, normal, equations) * norm_ - noncons_flux = nonconservative_flux_function(u_inner, u_mirror, normal, equations) * norm_ + noncons_flux = nonconservative_flux_function(u_inner, u_mirror, normal, equations) * + norm_ return flux, noncons_flux end diff --git a/src/equations/equations.jl b/src/equations/equations.jl index 2efee197bba..e907d18f3b7 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -197,14 +197,14 @@ end flux = surface_flux_function(u_inner, u_boundary, orientation_or_normal, equations) noncons_flux = nonconservative_flux_function(u_inner, u_boundary, - orientation_or_normal, - equations) + orientation_or_normal, + equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation_or_normal, equations) noncons_flux = nonconservative_flux_function(u_boundary, u_inner, - orientation_or_normal, - equations) + orientation_or_normal, + equations) end return flux, noncons_flux @@ -241,7 +241,7 @@ end # Calculate boundary flux flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) noncons_flux = nonconservative_flux_function(u_inner, u_boundary, normal_direction, - equations) + equations) return flux, noncons_flux end diff --git a/src/equations/shallow_water_1d.jl b/src/equations/shallow_water_1d.jl index 35834750080..fff045a70c3 100644 --- a/src/equations/shallow_water_1d.jl +++ b/src/equations/shallow_water_1d.jl @@ -175,14 +175,14 @@ For details see Section 9.2.5 of the book: flux = surface_flux_function(u_inner, u_boundary, orientation_or_normal, equations) noncons_flux = nonconservative_flux_function(u_inner, u_boundary, - orientation_or_normal, - equations) + orientation_or_normal, + equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation_or_normal, equations) noncons_flux = nonconservative_flux_function(u_boundary, u_inner, - orientation_or_normal, - equations) + orientation_or_normal, + equations) end return flux, noncons_flux diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index 263460e3c53..d07b2d3482f 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -199,7 +199,7 @@ For details see Section 9.2.5 of the book: # calculate the boundary flux flux = surface_flux_function(u_inner, u_boundary, normal_direction, equations) noncons_flux = nonconservative_flux_function(u_inner, u_boundary, normal_direction, - equations) + equations) return flux, noncons_flux end @@ -227,11 +227,11 @@ Should be used together with [`TreeMesh`](@ref). if iseven(direction) # u_inner is "left" of boundary, u_boundary is "right" of boundary flux = surface_flux_function(u_inner, u_boundary, orientation, equations) noncons_flux = nonconservative_flux_function(u_inner, u_boundary, orientation, - equations) + equations) else # u_boundary is "left" of boundary, u_inner is "right" of boundary flux = surface_flux_function(u_boundary, u_inner, orientation, equations) noncons_flux = nonconservative_flux_function(u_boundary, u_inner, orientation, - equations) + equations) end return flux, noncons_flux diff --git a/src/solvers/dgsem_p4est/dg_2d.jl b/src/solvers/dgsem_p4est/dg_2d.jl index 9931b31fa84..53c0ef50ce1 100644 --- a/src/solvers/dgsem_p4est/dg_2d.jl +++ b/src/solvers/dgsem_p4est/dg_2d.jl @@ -364,16 +364,16 @@ end # Call pointwise numerical flux function for the conservative part # in the normal direction on the boundary flux, noncons_flux = boundary_condition(u_inner, normal_direction, x, t, - surface_integral.surface_flux, equations) + surface_integral.surface_flux, equations) # Copy flux to element storage in the correct orientation for v in eachvariable(equations) # Note the factor 0.5 necessary for the nonconservative fluxes based on # the interpretation of global SBP operators coupled discontinuously via # central fluxes/SATs - surface_flux_values[v, node_index, direction_index, element_index] = flux_[v] + + surface_flux_values[v, node_index, direction_index, element_index] = flux[v] + 0.5f0 * - noncons_[v] + noncons_flux[v] end end From d26925ec6c4fce0bf4894012235a4815a569b6f8 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Wed, 8 Jan 2025 14:52:29 +0100 Subject: [PATCH 24/40] fix test type stability --- test/test_type.jl | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/test/test_type.jl b/test/test_type.jl index 41c47b651cc..9bc5249a6a2 100644 --- a/test/test_type.jl +++ b/test/test_type.jl @@ -2275,7 +2275,8 @@ isdir(outdir) && rm(outdir, recursive = true) direction, x, t, surface_flux_function, - equations)) == RealT + equations)) == + Tuple{RealT, RealT} @test eltype(@inferred Trixi.calc_wavespeed_roe(u_ll, u_rr, direction, equations)) == RealT @@ -2361,7 +2362,8 @@ isdir(outdir) && rm(outdir, recursive = true) normal_direction, x, t, surface_flux_function, - equations)) == RealT + equations)) == + Tuple{RealT, RealT} @test eltype(@inferred velocity(u, normal_direction, equations)) == RealT @test eltype(@inferred flux(u, normal_direction, equations)) == RealT @@ -2403,7 +2405,7 @@ isdir(outdir) && rm(outdir, recursive = true) direction, x, t, surface_flux_function, equations)) == - RealT + Tuple{RealT, RealT} end @test eltype(@inferred velocity(u, orientation, equations)) == RealT From 9b4e384e55944eee6ddebeb65b9a47b44d8a9b98 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Thu, 9 Jan 2025 09:38:36 +0100 Subject: [PATCH 25/40] fix test type stability --- test/test_type.jl | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/test/test_type.jl b/test/test_type.jl index 9bc5249a6a2..f9acf86e491 100644 --- a/test/test_type.jl +++ b/test/test_type.jl @@ -2276,7 +2276,7 @@ isdir(outdir) && rm(outdir, recursive = true) x, t, surface_flux_function, equations)) == - Tuple{RealT, RealT} + SVector{3, RealT} @test eltype(@inferred Trixi.calc_wavespeed_roe(u_ll, u_rr, direction, equations)) == RealT @@ -2363,7 +2363,7 @@ isdir(outdir) && rm(outdir, recursive = true) x, t, surface_flux_function, equations)) == - Tuple{RealT, RealT} + SVector{4, RealT} @test eltype(@inferred velocity(u, normal_direction, equations)) == RealT @test eltype(@inferred flux(u, normal_direction, equations)) == RealT @@ -2405,7 +2405,7 @@ isdir(outdir) && rm(outdir, recursive = true) direction, x, t, surface_flux_function, equations)) == - Tuple{RealT, RealT} + SVector{4, RealT} end @test eltype(@inferred velocity(u, orientation, equations)) == RealT From 8332bbe767250de452212965b974e8747d352886 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Fri, 24 Jan 2025 09:15:01 +0100 Subject: [PATCH 26/40] Update src/equations/shallow_water_1d.jl Co-authored-by: Andrew Winters --- src/equations/shallow_water_1d.jl | 1 + 1 file changed, 1 insertion(+) diff --git a/src/equations/shallow_water_1d.jl b/src/equations/shallow_water_1d.jl index fff045a70c3..8c7bf786cbf 100644 --- a/src/equations/shallow_water_1d.jl +++ b/src/equations/shallow_water_1d.jl @@ -164,6 +164,7 @@ For details see Section 9.2.5 of the book: equations::ShallowWaterEquations1D) # The boundary conditions for the non-conservative term are identically 0 here. + # Bottom topography is assumed to be continuous at the boundary. surface_flux_function, nonconservative_flux_function = surface_flux_functions # create the "external" boundary solution state u_boundary = SVector(u_inner[1], From 53d8a14e17e2964e2a57a6ca76dbd3ed1540b78a Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Fri, 24 Jan 2025 09:15:11 +0100 Subject: [PATCH 27/40] Update src/equations/shallow_water_2d.jl Co-authored-by: Andrew Winters --- src/equations/shallow_water_2d.jl | 1 + 1 file changed, 1 insertion(+) diff --git a/src/equations/shallow_water_2d.jl b/src/equations/shallow_water_2d.jl index d07b2d3482f..855d3f517fa 100644 --- a/src/equations/shallow_water_2d.jl +++ b/src/equations/shallow_water_2d.jl @@ -215,6 +215,7 @@ Should be used together with [`TreeMesh`](@ref). surface_flux_functions, equations::ShallowWaterEquations2D) # The boundary conditions for the non-conservative term are identically 0 here. + # Bottom topography is assumed to be continuous at the boundary. surface_flux_function, nonconservative_flux_function = surface_flux_functions ## get the appropriate normal vector from the orientation if orientation == 1 From a9e3823977dc54233db0f0ab8c1eb58ff330848e Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Mon, 3 Feb 2025 22:00:10 +0100 Subject: [PATCH 28/40] Update src/basic_types.jl Co-authored-by: Patrick Ersing <114223904+patrickersing@users.noreply.github.com> --- src/basic_types.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/basic_types.jl b/src/basic_types.jl index 891f815db32..0a3ffe896fc 100644 --- a/src/basic_types.jl +++ b/src/basic_types.jl @@ -71,7 +71,7 @@ struct BoundaryConditionDoNothing end orientation_or_normal_direction, direction::Integer, x, t, surface_flux, equations) - return surface_flux(u_inner, u_inner, orientation_or_normal_direction, equations) + return flux(u_inner, orientation_or_normal_direction, equations) end # This version can be called by hyperbolic solvers on logically Cartesian meshes From f27b8cfac6a7a9c4b28698da51b1e86a9aad7b98 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Mon, 3 Feb 2025 22:00:20 +0100 Subject: [PATCH 29/40] Update src/basic_types.jl Co-authored-by: Patrick Ersing <114223904+patrickersing@users.noreply.github.com> --- src/basic_types.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/basic_types.jl b/src/basic_types.jl index 0a3ffe896fc..2c6005a1864 100644 --- a/src/basic_types.jl +++ b/src/basic_types.jl @@ -91,7 +91,7 @@ end @inline function (::BoundaryConditionDoNothing)(u_inner, outward_direction::AbstractVector, x, t, surface_flux, equations) - return surface_flux(u_inner, u_inner, outward_direction, equations) + return flux(u_inner, outward_direction, equations) end @inline function (::BoundaryConditionDoNothing)(u_inner, From 05bff3243d95b7228425fbaa500c2afb5022c663 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Mon, 3 Feb 2025 22:00:40 +0100 Subject: [PATCH 30/40] Update src/solvers/dgsem_p4est/dg_2d.jl Co-authored-by: Patrick Ersing <114223904+patrickersing@users.noreply.github.com> --- src/solvers/dgsem_p4est/dg_2d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/solvers/dgsem_p4est/dg_2d.jl b/src/solvers/dgsem_p4est/dg_2d.jl index 53c0ef50ce1..465721bb163 100644 --- a/src/solvers/dgsem_p4est/dg_2d.jl +++ b/src/solvers/dgsem_p4est/dg_2d.jl @@ -361,7 +361,7 @@ end x = get_node_coords(node_coordinates, equations, dg, i_index, j_index, element_index) - # Call pointwise numerical flux function for the conservative part + # Call pointwise numerical flux functions for the conservative and nonconservative part # in the normal direction on the boundary flux, noncons_flux = boundary_condition(u_inner, normal_direction, x, t, surface_integral.surface_flux, equations) From 7f4ff1ae4951f7ae4ea734fb410d97559f8b412e Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Mon, 3 Feb 2025 22:00:47 +0100 Subject: [PATCH 31/40] Update src/solvers/dgsem_unstructured/dg_2d.jl Co-authored-by: Patrick Ersing <114223904+patrickersing@users.noreply.github.com> --- src/solvers/dgsem_unstructured/dg_2d.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/solvers/dgsem_unstructured/dg_2d.jl b/src/solvers/dgsem_unstructured/dg_2d.jl index 34effb1f11f..9f2bb7ac1a0 100644 --- a/src/solvers/dgsem_unstructured/dg_2d.jl +++ b/src/solvers/dgsem_unstructured/dg_2d.jl @@ -439,7 +439,7 @@ end # get the external solution values from the prescribed external state x = get_node_coords(node_coordinates, equations, dg, node_index, boundary_index) - # Call pointwise numerical flux function for the conservative part + # Call pointwise numerical flux functions for the conservative and nonconservative part # in the normal direction on the boundary flux, noncons_flux = boundary_condition(u_inner, outward_direction, x, t, surface_integral.surface_flux, equations) From 8e5af142546be50c9c2ec22a8ad8280ceb995990 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Mon, 3 Feb 2025 22:00:54 +0100 Subject: [PATCH 32/40] Update src/solvers/dgsem_unstructured/dg_2d.jl Co-authored-by: Patrick Ersing <114223904+patrickersing@users.noreply.github.com> --- src/solvers/dgsem_unstructured/dg_2d.jl | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/solvers/dgsem_unstructured/dg_2d.jl b/src/solvers/dgsem_unstructured/dg_2d.jl index 9f2bb7ac1a0..619cdb737de 100644 --- a/src/solvers/dgsem_unstructured/dg_2d.jl +++ b/src/solvers/dgsem_unstructured/dg_2d.jl @@ -444,8 +444,6 @@ end flux, noncons_flux = boundary_condition(u_inner, outward_direction, x, t, surface_integral.surface_flux, equations) - # Compute pointwise nonconservative numerical flux at the boundary. - for v in eachvariable(equations) # Note the factor 0.5 necessary for the nonconservative fluxes based on # the interpretation of global SBP operators coupled discontinuously via From bf2401123d3c3e0793884aa80616d9253d16d749 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Mon, 3 Feb 2025 22:01:01 +0100 Subject: [PATCH 33/40] Update src/basic_types.jl Co-authored-by: Daniel Doehring --- src/basic_types.jl | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/basic_types.jl b/src/basic_types.jl index 2c6005a1864..470f21063d2 100644 --- a/src/basic_types.jl +++ b/src/basic_types.jl @@ -81,8 +81,8 @@ end surface_flux_functions::Tuple, equations) surface_flux_function, nonconservative_flux_function = surface_flux_functions - return surface_flux_function(u_inner, u_inner, orientation_or_normal_direction, - equations), + return surface_flux_function(u_inner, u_inner, + orientation_or_normal_direction, equations), nonconservative_flux_function(u_inner, u_inner, orientation_or_normal_direction, equations) end From dfe11168b56ba509834a1c8860a89ffabdb434b7 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Mon, 3 Feb 2025 22:16:45 +0100 Subject: [PATCH 34/40] formatting --- src/basic_types.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/basic_types.jl b/src/basic_types.jl index 470f21063d2..42475b1d855 100644 --- a/src/basic_types.jl +++ b/src/basic_types.jl @@ -81,7 +81,7 @@ end surface_flux_functions::Tuple, equations) surface_flux_function, nonconservative_flux_function = surface_flux_functions - return surface_flux_function(u_inner, u_inner, + return surface_flux_function(u_inner, u_inner, orientation_or_normal_direction, equations), nonconservative_flux_function(u_inner, u_inner, orientation_or_normal_direction, equations) From d24578e497fba6a62e5aa4521918fa31260e2ff2 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Tue, 4 Feb 2025 14:22:50 +0100 Subject: [PATCH 35/40] Update src/basic_types.jl Co-authored-by: Daniel Doehring --- src/basic_types.jl | 1 + 1 file changed, 1 insertion(+) diff --git a/src/basic_types.jl b/src/basic_types.jl index 42475b1d855..1aaf6d6d464 100644 --- a/src/basic_types.jl +++ b/src/basic_types.jl @@ -94,6 +94,7 @@ end return flux(u_inner, outward_direction, equations) end +# Version for equations involving nonconservative fluxes @inline function (::BoundaryConditionDoNothing)(u_inner, outward_direction::AbstractVector, x, t, surface_flux_functions::Tuple, From 0e09a32f765ad0e57e220da038576faef38b65b0 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Fri, 7 Feb 2025 11:07:15 +0100 Subject: [PATCH 36/40] Update test/test_type.jl Co-authored-by: Hendrik Ranocha --- test/test_type.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_type.jl b/test/test_type.jl index f9acf86e491..49aabbd29d1 100644 --- a/test/test_type.jl +++ b/test/test_type.jl @@ -2258,7 +2258,7 @@ isdir(outdir) && rm(outdir, recursive = true) directions = [1, 2] normal_direction = SVector(one(RealT)) - surface_flux_function = (flux_lax_friedrichs, flux_lax_friedrichs) + surface_flux_function = (flux_lax_friedrichs, flux_nonconservative_wintermeyer_etal) dissipation = DissipationLocalLaxFriedrichs() numflux = FluxHLL() From fe7803bae5910ffeed06e9e2f76c1c1e6c705af6 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Fri, 7 Feb 2025 11:07:26 +0100 Subject: [PATCH 37/40] Update test/test_type.jl Co-authored-by: Hendrik Ranocha --- test/test_type.jl | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/test/test_type.jl b/test/test_type.jl index 49aabbd29d1..ef07e6767cb 100644 --- a/test/test_type.jl +++ b/test/test_type.jl @@ -2348,7 +2348,7 @@ isdir(outdir) && rm(outdir, recursive = true) directions = [1, 2, 3, 4] normal_direction = SVector(one(RealT), zero(RealT)) - surface_flux_function = (flux_lax_friedrichs, flux_lax_friedrichs) + surface_flux_function = (flux_lax_friedrichs, flux_nonconservative_wintermeyer_etal) dissipation = DissipationLocalLaxFriedrichs() numflux = FluxHLL() From d3225fc000c551c7f3e4fbfd9c0f2beca183a33a Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Fri, 7 Feb 2025 11:08:13 +0100 Subject: [PATCH 38/40] Update src/equations/equations.jl Co-authored-by: Hendrik Ranocha --- src/equations/equations.jl | 1 + 1 file changed, 1 insertion(+) diff --git a/src/equations/equations.jl b/src/equations/equations.jl index e907d18f3b7..f43e6d49311 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -182,6 +182,7 @@ end end # Dirichlet-type boundary condition for use with TreeMesh or StructuredMesh +# passing a tuple of surface flux functions for nonconservative terms @inline function (boundary_condition::BoundaryConditionDirichlet)(u_inner, orientation_or_normal, direction, From b538a1cdc16629963b1a478721db2fa891d14f99 Mon Sep 17 00:00:00 2001 From: Marco Artiano <57838732+MarcoArtiano@users.noreply.github.com> Date: Fri, 7 Feb 2025 11:08:24 +0100 Subject: [PATCH 39/40] Update src/equations/equations.jl Co-authored-by: Hendrik Ranocha --- src/equations/equations.jl | 1 + 1 file changed, 1 insertion(+) diff --git a/src/equations/equations.jl b/src/equations/equations.jl index f43e6d49311..e63f9064238 100644 --- a/src/equations/equations.jl +++ b/src/equations/equations.jl @@ -228,6 +228,7 @@ end end # Dirichlet-type boundary condition for equations with non-conservative terms for use with UnstructuredMesh2D +# passing a tuple of surface flux functions for nonconservative terms # Note: For unstructured we lose the concept of an "absolute direction" @inline function (boundary_condition::BoundaryConditionDirichlet)(u_inner, normal_direction::AbstractVector, From c85aba7fe6e7fc355dba107a68c7901b7ff7fdf3 Mon Sep 17 00:00:00 2001 From: Marco Artiano Date: Fri, 7 Feb 2025 12:43:08 +0100 Subject: [PATCH 40/40] add docs --- NEWS.md | 4 ++++ docs/literate/src/files/adding_nonconservative_equation.jl | 3 +++ docs/literate/src/files/non_periodic_boundaries.jl | 5 +++++ test/test_type.jl | 6 ++++-- 4 files changed, 16 insertions(+), 2 deletions(-) diff --git a/NEWS.md b/NEWS.md index da813781251..5506357e2cb 100644 --- a/NEWS.md +++ b/NEWS.md @@ -23,6 +23,10 @@ for human readability. Previously, only the first 8 digits were printed to file. Furthermore, the names of the printed fields are now only separated by a single white space, in contrast to before where this were multiple, depending on the actual name of the printed data. +- The boundary conditions for non-conservative equations can now be defined separately from the conservative part. + The `surface_flux_functions` tuple is now passed directly to the boundary condition call, + returning a tuple with boundary condition values for both the conservative and non-conservative parts ([#2200]). + #### Deprecated diff --git a/docs/literate/src/files/adding_nonconservative_equation.jl b/docs/literate/src/files/adding_nonconservative_equation.jl index 933341f0128..62f89fafbd9 100644 --- a/docs/literate/src/files/adding_nonconservative_equation.jl +++ b/docs/literate/src/files/adding_nonconservative_equation.jl @@ -177,6 +177,9 @@ error_1 / error_2 # As expected, the new error is roughly reduced by a factor of 16, corresponding # to an experimental order of convergence of 4 (for polynomials of degree 3). +# For non-trivial boundary conditions involving non-conservative terms, +# please refer to the section on [Other available example elixirs with non-trivial BC](https://trixi-framework.github.io/Trixi.jl/stable/tutorials/non_periodic_boundaries/#Other-available-example-elixirs-with-non-trivial-BC). + # ## Summary of the code # Here is the complete code that we used (without the callbacks since these diff --git a/docs/literate/src/files/non_periodic_boundaries.jl b/docs/literate/src/files/non_periodic_boundaries.jl index 8312f9e64a1..0c21ec9a4f6 100644 --- a/docs/literate/src/files/non_periodic_boundaries.jl +++ b/docs/literate/src/files/non_periodic_boundaries.jl @@ -158,6 +158,11 @@ end # ``` # Source: [`Video`](https://www.youtube.com/watch?v=w0A9X38cSe4) on Trixi.jl's YouTube channel [`Trixi Framework`](https://www.youtube.com/watch?v=WElqqdMhY4A) +# Furthermore, Trixi.jl also handles equations that include non-conservative terms. +# For such equations, the tuple of conservative and non-conservative surfaces fluxes is passed to the boundary condition, +# which then returns a tuple containing the boundary condition values for both the conservative and non-conservative terms. +# For instance, a 2D ideal compressible GLM-MHD setup with reflective walls can be found in the elixir ['elixir_mhd_reflective_wall.jl](https://github.com/trixi-framework/Trixi.jl/blob/main/examples/dgmulti_2d/elixir_mhd_reflective_wall.jl). + # ## Package versions # These results were obtained using the following versions. diff --git a/test/test_type.jl b/test/test_type.jl index ef07e6767cb..fe523bde9b2 100644 --- a/test/test_type.jl +++ b/test/test_type.jl @@ -2258,7 +2258,8 @@ isdir(outdir) && rm(outdir, recursive = true) directions = [1, 2] normal_direction = SVector(one(RealT)) - surface_flux_function = (flux_lax_friedrichs, flux_nonconservative_wintermeyer_etal) + surface_flux_function = (flux_lax_friedrichs, + flux_nonconservative_wintermeyer_etal) dissipation = DissipationLocalLaxFriedrichs() numflux = FluxHLL() @@ -2348,7 +2349,8 @@ isdir(outdir) && rm(outdir, recursive = true) directions = [1, 2, 3, 4] normal_direction = SVector(one(RealT), zero(RealT)) - surface_flux_function = (flux_lax_friedrichs, flux_nonconservative_wintermeyer_etal) + surface_flux_function = (flux_lax_friedrichs, + flux_nonconservative_wintermeyer_etal) dissipation = DissipationLocalLaxFriedrichs() numflux = FluxHLL()