20679838146

Committed 03 Jan 2026 04:24PM UTC coverage: 96.993%. Remained the same

Build # 20679838146

Build Type

push

github

Committed by

ranocha

Commit Message

set development version to v0.13.22-DEV

Run Details

42292 of 43603 relevant lines covered (96.99%)

104628030.91 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 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 grid-transfer methods used for AMR,
45	# e.g. refinement and coarsening based on L² projections
46	abstract type AdaptorAMR{RealT <: Real} end
47
48	# abstract supertype of AMR grid-transfer operations using L² projections
49	# which will be specialized for different SBP bases
50	abstract type AdaptorL2{RealT <: Real} <: AdaptorAMR{RealT} end
51
52	# TODO: Taal decide, which abstract types shall be defined here?
53
54	struct BoundaryConditionPeriodic end	694✔
55
56	"""
57	boundary_condition_periodic = Trixi.BoundaryConditionPeriodic()
58
59	A singleton struct indicating periodic boundary conditions.
60	"""
61	const boundary_condition_periodic = BoundaryConditionPeriodic()
62
63	function Base.show(io::IO, ::BoundaryConditionPeriodic)	261✔
64	print(io, "boundary_condition_periodic")	261✔
65	return nothing	261✔
66	end
67
68	struct BoundaryConditionDoNothing end	70✔
69
70	# This version can be called by hyperbolic solvers on logically Cartesian meshes
71	@inline function (::BoundaryConditionDoNothing)(u_inner,	68,082,169✔
72	orientation_or_normal_direction,
73	direction::Integer, x, t, surface_flux,
74	equations)
75	return flux(u_inner, orientation_or_normal_direction, equations)	68,087,545✔
76	end
77
78	# This version can be called by hyperbolic solvers on logically Cartesian meshes
79	@inline function (::BoundaryConditionDoNothing)(u_inner,	1✔
80	orientation_or_normal_direction,
81	direction::Integer, x, t,
82	surface_flux_functions::Tuple,
83	equations)
84	surface_flux_function, nonconservative_flux_function = surface_flux_functions	1✔
85	return surface_flux_function(u_inner, u_inner,	1✔
86	orientation_or_normal_direction, equations),
87	nonconservative_flux_function(u_inner, u_inner,
88	orientation_or_normal_direction, equations)
89	end
90
91	# This version can be called by hyperbolic solvers on unstructured, curved meshes
92	@inline function (::BoundaryConditionDoNothing)(u_inner,	1,054,897✔
93	outward_direction::AbstractVector,
94	x, t, surface_flux, equations)
95	return flux(u_inner, outward_direction, equations)	1,054,897✔
96	end
97
98	# Version for equations involving nonconservative fluxes
99	@inline function (::BoundaryConditionDoNothing)(u_inner,	6,913✔
100	outward_direction::AbstractVector,
101	x, t, surface_flux_functions::Tuple,
102	equations)
103	surface_flux_function, nonconservative_flux_function = surface_flux_functions	6,913✔
104
105	return surface_flux_function(u_inner, u_inner, outward_direction, equations),	6,913✔
106	nonconservative_flux_function(u_inner, u_inner, outward_direction,
107	equations)
108	end
109
110	# This version can be called by parabolic solvers
111	@inline function (::BoundaryConditionDoNothing)(inner_flux_or_state, other_args...)	3✔
112	return inner_flux_or_state	3✔
113	end
114
115	"""
116	boundary_condition_do_nothing = Trixi.BoundaryConditionDoNothing()
117
118	Imposing no boundary condition just evaluates the flux at the inner state.
119	"""
120	const boundary_condition_do_nothing = BoundaryConditionDoNothing()
121
122	function Base.show(io::IO, ::BoundaryConditionDoNothing)	9✔
123	print(io, "boundary_condition_do_nothing")	9✔
124	return nothing	9✔
125	end
126	end # @muladd

trixi-framework / Trixi.jl / 20679838146

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