26329654322

Committed 23 May 2026 09:49AM UTC coverage: 96.897% (+2.7%) from 94.161%

Build # 26329654322

Build Type

push

github

Committed by

ranocha

Commit Message

set development version to v0.16.13-DEV

Coverage Stats

47707 of 49235 relevant lines covered (96.9%)

104650470.09 hits per line

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

100.0

/src/basic_types.jl

# By default, Julia/LLVM does not use fused multiply-add operations (FMAs).
# Since these FMAs can increase the performance of many numerical algorithms,
# we need to opt-in explicitly.
# See https://ranocha.de/blog/Optimizing_EC_Trixi for further details.
@muladd begin
#! format: noindent

# abstract supertype of specific semidiscretizations such as
# - SemidiscretizationHyperbolic for hyperbolic conservation laws
# - SemidiscretizationEulerGravity for Euler with self-gravity
abstract type AbstractSemidiscretization end

"""
    AbstractEquations{NDIMS, NVARS}

An abstract supertype of specific equations such as the compressible Euler equations.
The type parameters encode the number of spatial dimensions (`NDIMS`) and the
number of primary variables (`NVARS`) of the physics model.
"""
abstract type AbstractEquations{NDIMS, NVARS} end

"""
    AbstractMesh{NDIMS}

An abstract supertype of specific mesh types such as `TreeMesh` or `StructuredMesh`.
The type parameters encode the number of spatial dimensions (`NDIMS`).
"""
abstract type AbstractMesh{NDIMS} end

# abstract supertype of specific SBP bases such as a Lobatto-Legendre nodal basis
abstract type AbstractBasisSBP{RealT <: Real} end

# abstract supertype of mortar methods, e.g. using L² projections
abstract type AbstractMortar{RealT <: Real} end

# abstract supertype of mortar methods using L² projection
# which will be specialized for different SBP bases
abstract type AbstractMortarL2{RealT <: Real} <: AbstractMortar{RealT} end

# abstract supertype of functionality related to the analysis of
# numerical solutions, e.g. the calculation of errors
abstract type SolutionAnalyzer{RealT <: Real} end

# Abstract supertype of indicators used for AMR, shock capturing, and
# adaptive volume-integral selection
abstract type AbstractIndicator end

# abstract supertype of grid-transfer methods used for AMR,
# e.g. refinement and coarsening based on L² projections
abstract type AdaptorAMR{RealT <: Real} end

# abstract supertype of AMR grid-transfer operations using L² projections
# which will be specialized for different SBP bases
abstract type AdaptorL2{RealT <: Real} <: AdaptorAMR{RealT} end

# TODO: Taal decide, which abstract types shall be defined here?

struct BoundaryConditionPeriodic end

"""
    boundary_condition_periodic = Trixi.BoundaryConditionPeriodic()

A singleton struct indicating periodic boundary conditions.
"""
const boundary_condition_periodic = BoundaryConditionPeriodic()

function Base.show(io::IO, ::BoundaryConditionPeriodic)
    print(io, "boundary_condition_periodic")
    return nothing
end

struct BoundaryConditionDoNothing 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,
                                                equations)
    return flux(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),
           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,
                                                x, t, surface_flux, equations)
    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,
                                                equations)
    surface_flux_function, nonconservative_flux_function = surface_flux_functions

    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
@inline function (::BoundaryConditionDoNothing)(inner_flux_or_state, other_args...)
    return inner_flux_or_state
end

"""
    boundary_condition_do_nothing = Trixi.BoundaryConditionDoNothing()

Imposing no boundary condition just evaluates the flux at the inner state.
"""
const boundary_condition_do_nothing = BoundaryConditionDoNothing()

function Base.show(io::IO, ::BoundaryConditionDoNothing)
    print(io, "boundary_condition_do_nothing")
    return nothing
end
end # @muladd

1	# By default, Julia/LLVM does not use fused multiply-add operations (FMAs).
2	# Since these FMAs can increase the performance of many numerical algorithms,
3	# we need to opt-in explicitly.
4	# See https://ranocha.de/blog/Optimizing_EC_Trixi for further details.
5	@muladd begin
6	#! format: noindent
7
8	# abstract supertype of specific semidiscretizations such as
9	# - SemidiscretizationHyperbolic for hyperbolic conservation laws
10	# - SemidiscretizationEulerGravity for Euler with self-gravity
11	abstract type AbstractSemidiscretization end
12
13	"""
14	AbstractEquations{NDIMS, NVARS}
15
16	An abstract supertype of specific equations such as the compressible Euler equations.
17	The type parameters encode the number of spatial dimensions (`NDIMS`) and the
18	number of primary variables (`NVARS`) of the physics model.
19	"""
20	abstract type AbstractEquations{NDIMS, NVARS} end
21
22	"""
23	AbstractMesh{NDIMS}
24
25	An abstract supertype of specific mesh types such as `TreeMesh` or `StructuredMesh`.
26	The type parameters encode the number of spatial dimensions (`NDIMS`).
27	"""
28	abstract type AbstractMesh{NDIMS} end
29
30	# abstract supertype of specific SBP bases such as a Lobatto-Legendre nodal basis
31	abstract type AbstractBasisSBP{RealT <: Real} end
32
33	# abstract supertype of mortar methods, e.g. using L² projections
34	abstract type AbstractMortar{RealT <: Real} end
35
36	# abstract supertype of mortar methods using L² projection
37	# which will be specialized for different SBP bases
38	abstract type AbstractMortarL2{RealT <: Real} <: AbstractMortar{RealT} end
39
40	# abstract supertype of functionality related to the analysis of
41	# numerical solutions, e.g. the calculation of errors
42	abstract type SolutionAnalyzer{RealT <: Real} end
43
44	# Abstract supertype of indicators used for AMR, shock capturing, and
45	# adaptive volume-integral selection
46	abstract type AbstractIndicator end
47
48	# abstract supertype of grid-transfer methods used for AMR,
49	# e.g. refinement and coarsening based on L² projections
50	abstract type AdaptorAMR{RealT <: Real} end
51
52	# abstract supertype of AMR grid-transfer operations using L² projections
53	# which will be specialized for different SBP bases
54	abstract type AdaptorL2{RealT <: Real} <: AdaptorAMR{RealT} end
55
56	# TODO: Taal decide, which abstract types shall be defined here?
57
58	struct BoundaryConditionPeriodic end	79✔
59
60	"""
61	boundary_condition_periodic = Trixi.BoundaryConditionPeriodic()
62
63	A singleton struct indicating periodic boundary conditions.
64	"""
65	const boundary_condition_periodic = BoundaryConditionPeriodic()
66
67	function Base.show(io::IO, ::BoundaryConditionPeriodic)	179✔
68	print(io, "boundary_condition_periodic")	179✔
69	return nothing	179✔
70	end
71
72	struct BoundaryConditionDoNothing end	79✔
73
74	# This version can be called by hyperbolic solvers on logically Cartesian meshes
75	@inline function (::BoundaryConditionDoNothing)(u_inner,	102,052,829✔
76	orientation_or_normal_direction,
77	direction::Integer, x, t, surface_flux,
78	equations)
79	return flux(u_inner, orientation_or_normal_direction, equations)	102,058,205✔
80	end
81
82	# This version can be called by hyperbolic solvers on logically Cartesian meshes
83	@inline function (::BoundaryConditionDoNothing)(u_inner,	3✔
84	orientation_or_normal_direction,
85	direction::Integer, x, t,
86	surface_flux_functions::Tuple,
87	equations)
88	surface_flux_function, nonconservative_flux_function = surface_flux_functions	3✔
89	return surface_flux_function(u_inner, u_inner,	3✔
90	orientation_or_normal_direction, equations),
91	nonconservative_flux_function(u_inner, u_inner,
92	orientation_or_normal_direction, equations)
93	end
94
95	# This version can be called by hyperbolic solvers on unstructured, curved meshes
96	@inline function (::BoundaryConditionDoNothing)(u_inner,	34,045,299✔
97	outward_direction::AbstractVector,
98	x, t, surface_flux, equations)
99	return flux(u_inner, outward_direction, equations)	34,045,299✔
100	end
101
102	# Version for equations involving nonconservative fluxes
103	@inline function (::BoundaryConditionDoNothing)(u_inner,	6,915✔
104	outward_direction::AbstractVector,
105	x, t, surface_flux_functions::Tuple,
106	equations)
107	surface_flux_function, nonconservative_flux_function = surface_flux_functions	6,915✔
108
109	return surface_flux_function(u_inner, u_inner, outward_direction, equations),	6,915✔
110	nonconservative_flux_function(u_inner, u_inner, outward_direction,
111	equations)
112	end
113
114	# This version can be called by parabolic solvers
115	@inline function (::BoundaryConditionDoNothing)(inner_flux_or_state, other_args...)	1✔
116	return inner_flux_or_state	1✔
117	end
118
119	"""
120	boundary_condition_do_nothing = Trixi.BoundaryConditionDoNothing()
121
122	Imposing no boundary condition just evaluates the flux at the inner state.
123	"""
124	const boundary_condition_do_nothing = BoundaryConditionDoNothing()
125
126	function Base.show(io::IO, ::BoundaryConditionDoNothing)	13✔
127	print(io, "boundary_condition_do_nothing")	13✔
128	return nothing	13✔
129	end
130	end # @muladd

trixi-framework / Trixi.jl / 26329654322

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

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