25562531820

Committed 08 May 2026 02:56PM UTC coverage: 93.484% (-3.6%) from 97.131%

Build # 25562531820

Build Type

push

github

Committed by

web-flow

Commit Message

Prevent init_mpi from being automatically called during precompilation. (#2993)

Ideally we would avoid all precompilation under MPI, and that is our
recommendation to users. Yet, we have scene the situation in CI, where
an extension of Trixi gets recompiled due to a difference in flags,
leading to crashes and hangs.

Co-authored-by: Hendrik Ranocha <ranocha@users.noreply.github.com>

Coverage Stats

2 of 2 new or added lines in 1 file covered. (100.0%)

1769 existing lines in 82 files now uncovered.

45353 of 48514 relevant lines covered (93.48%)

36730339.97 hits per line

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

90.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	29✔
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)	59✔
68	print(io, "boundary_condition_periodic")	59✔
69	return nothing	59✔
70	end
71
72	struct BoundaryConditionDoNothing end	29✔
73
74	# This version can be called by hyperbolic solvers on logically Cartesian meshes
75	@inline function (::BoundaryConditionDoNothing)(u_inner,	33,973,735✔
76	orientation_or_normal_direction,
77	direction::Integer, x, t, surface_flux,
78	equations)
79	return flux(u_inner, orientation_or_normal_direction, equations)	33,975,527✔
80	end
81
82	# This version can be called by hyperbolic solvers on logically Cartesian meshes
83	@inline function (::BoundaryConditionDoNothing)(u_inner,	1✔
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	1✔
89	return surface_flux_function(u_inner, u_inner,	1✔
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,	11,224,449✔
97	outward_direction::AbstractVector,
98	x, t, surface_flux, equations)
99	return flux(u_inner, outward_direction, equations)	11,224,449✔
100	end
101
102	# Version for equations involving nonconservative fluxes
103	@inline function (::BoundaryConditionDoNothing)(u_inner,	2,305✔
104	outward_direction::AbstractVector,
105	x, t, surface_flux_functions::Tuple,
106	equations)
107	surface_flux_function, nonconservative_flux_function = surface_flux_functions	2,305✔
108
109	return surface_flux_function(u_inner, u_inner, outward_direction, equations),	2,305✔
110	nonconservative_flux_function(u_inner, u_inner, outward_direction,
111	equations)
112	end
113
114	# This version can be called by parabolic solvers
UNCOV 115	@inline function (::BoundaryConditionDoNothing)(inner_flux_or_state, other_args...)	×
UNCOV 116	return inner_flux_or_state	×
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)	4✔
127	print(io, "boundary_condition_do_nothing")	4✔
128	return nothing	4✔
129	end
130	end # @muladd

trixi-framework / Trixi.jl / 25562531820

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