18561934460

Committed 16 Oct 2025 12:54PM UTC coverage: 65.961% (-0.03%) from 65.988%

Build # 18561934460

Build Type

push

github

Committed by

web-flow

Commit Message

Removed `test_case` and made several dispatches more precise (#104)

* Removed `test_case`.

* Made several dispatches more precise.

* Removed `examples.md` (was comitted by accident).

* Renamed `AbstractVariable` to `AbstractPredictand` and removed some of its subtypes (these are direct subtypes of `Any` now).

* Some simplifications and additional comments in initialize_rays!.

* Corrected a few typos.

* Moved the namelist parameter "model" to AtmosphereNamelist and removed SettingNamelist. Reformatted the code.

Run Details

104 of 119 new or added lines in 44 files covered. (87.39%)

4 existing lines in 4 files now uncovered.

4951 of 7506 relevant lines covered (65.96%)

1423740.77 hits per line

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

74.07

/src/Update/compute_volume_force.jl

"""
```julia
compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::Union{U, V, W, P, Chi},
)::AbstractFloat
```

Return the volume force in the equation specified by `variable`, by dispatching to an equation-and-WKB-mode specific method.

```julia
compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::Union{U, V, W, Chi},
    wkb_mode::NoWKB,
)::AbstractFloat
```

Return ``0`` as the volume force in non-WKB configurations (for all variables except the mass-weighted potential temperature).

```julia
compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::U,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
```

Return the gravity-wave drag on the zonal momentum, interpolated to ``\\left(i + 1 / 2, j, k\\right)``.

```julia
compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::V,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
```

Return the gravity-wave drag on the meridional momentum, interpolated to ``\\left(i, j + 1 / 2, k\\right)``.

```julia
compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::W,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
```

Return the gravity-wave drag on the transformed vertical momentum, interpolated to ``\\left(i, j, k + 1 / 2\\right)``, as given by

```math
\\left(\\frac{\\partial \\widehat{w}}{\\partial t}\\right)_\\mathrm{w} = \\left[G^{1 3} \\left(\\frac{\\partial u}{\\partial t}\\right)_\\mathrm{w}\\right]_{k + 1 / 2} + \\left[G^{2 3} \\left(\\frac{\\partial v}{\\partial t}\\right)_\\mathrm{w}\\right]_{k + 1 / 2}.
```

```julia
compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::P,
    wkb_mode::NoWKB,
)::AbstractFloat
```

Return the conductive heating.

```julia
compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::P,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
```

Return the sum of gravity-wave impact on the mass-weighted potential temperature and conductive heating.

```julia
compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variables::Chi,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
```

Return the tracer flux convergence due to gravity waves.

# Arguments

  - `state`: Model state.

  - `i`: Zonal grid-cell index.

  - `j`: Meridional grid-cell index.

  - `k`: Vertical grid-cell index.

  - `variable`: Variable (equation) of choice.

  - `wkb_mode`: Approximations used by MSGWaM.

# See also

  - [`PinCFlow.Update.conductive_heating`](@ref)
"""
function compute_volume_force end

function compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::Union{U, V, W, P, Chi},
)::AbstractFloat
    (; wkb_mode) = state.namelists.wkb

    return compute_volume_force(state, i, j, k, variable, wkb_mode)
end

function compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::Union{U, V, W, Chi},
    wkb_mode::NoWKB,
)::AbstractFloat
    return 0.0
end

function compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::U,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
    (; dudt) = state.wkb.tendencies

    @ivy return (dudt[i, j, k] + dudt[i + 1, j, k]) / 2
end

function compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::V,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
    (; dvdt) = state.wkb.tendencies

    @ivy return (dvdt[i, j, k] + dvdt[i, j + 1, k]) / 2
end

function compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::W,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
    (; jac, met) = state.grid
    (; dudt, dvdt) = state.wkb.tendencies

    @ivy return (
        jac[i, j, k + 1] * (
            met[i, j, k, 1, 3] * dudt[i, j, k] +
            met[i, j, k, 2, 3] * dvdt[i, j, k]
        ) +
        jac[i, j, k] * (
            met[i, j, k + 1, 1, 3] * dudt[i, j, k + 1] +
            met[i, j, k + 1, 2, 3] * dvdt[i, j, k + 1]
        )
    ) / (jac[i, j, k] + jac[i, j, k + 1])
end

function compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::P,
    wkb_mode::NoWKB,
)::AbstractFloat
    return conductive_heating(state, i, j, k)
end

function compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variable::P,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
    (; dthetadt) = state.wkb.tendencies

    @ivy return dthetadt[i, j, k] + conductive_heating(state, i, j, k)
end

function compute_volume_force(
    state::State,
    i::Integer,
    j::Integer,
    k::Integer,
    variables::Chi,
    wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
)::AbstractFloat
    (; leading_order_impact) = state.namelists.tracer
    (; chiq0) = state.tracer.tracerforcings
    (; model) = state.namelists.atmosphere

    @ivy if leading_order_impact && model == Compressible()
        return chiq0.dchidt[i, j, k]
    else
        return 0.0
    end
end

1	"""
2	```julia
3	compute_volume_force(
4	state::State,
5	i::Integer,
6	j::Integer,
7	k::Integer,
8	variable::Union{U, V, W, P, Chi},
9	)::AbstractFloat
10	```
11
12	Return the volume force in the equation specified by `variable`, by dispatching to an equation-and-WKB-mode specific method.
13
14	```julia
15	compute_volume_force(
16	state::State,
17	i::Integer,
18	j::Integer,
19	k::Integer,
20	variable::Union{U, V, W, Chi},
21	wkb_mode::NoWKB,
22	)::AbstractFloat
23	```
24
25	Return ``0`` as the volume force in non-WKB configurations (for all variables except the mass-weighted potential temperature).
26
27	```julia
28	compute_volume_force(
29	state::State,
30	i::Integer,
31	j::Integer,
32	k::Integer,
33	variable::U,
34	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
35	)::AbstractFloat
36	```
37
38	Return the gravity-wave drag on the zonal momentum, interpolated to ``\\left(i + 1 / 2, j, k\\right)``.
39
40	```julia
41	compute_volume_force(
42	state::State,
43	i::Integer,
44	j::Integer,
45	k::Integer,
46	variable::V,
47	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
48	)::AbstractFloat
49	```
50
51	Return the gravity-wave drag on the meridional momentum, interpolated to ``\\left(i, j + 1 / 2, k\\right)``.
52
53	```julia
54	compute_volume_force(
55	state::State,
56	i::Integer,
57	j::Integer,
58	k::Integer,
59	variable::W,
60	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
61	)::AbstractFloat
62	```
63
64	Return the gravity-wave drag on the transformed vertical momentum, interpolated to ``\\left(i, j, k + 1 / 2\\right)``, as given by
65
66	```math
67	\\left(\\frac{\\partial \\widehat{w}}{\\partial t}\\right)_\\mathrm{w} = \\left[G^{1 3} \\left(\\frac{\\partial u}{\\partial t}\\right)_\\mathrm{w}\\right]_{k + 1 / 2} + \\left[G^{2 3} \\left(\\frac{\\partial v}{\\partial t}\\right)_\\mathrm{w}\\right]_{k + 1 / 2}.
68	```
69
70	```julia
71	compute_volume_force(
72	state::State,
73	i::Integer,
74	j::Integer,
75	k::Integer,
76	variable::P,
77	wkb_mode::NoWKB,
78	)::AbstractFloat
79	```
80
81	Return the conductive heating.
82
83	```julia
84	compute_volume_force(
85	state::State,
86	i::Integer,
87	j::Integer,
88	k::Integer,
89	variable::P,
90	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
91	)::AbstractFloat
92	```
93
94	Return the sum of gravity-wave impact on the mass-weighted potential temperature and conductive heating.
95
96	```julia
97	compute_volume_force(
98	state::State,
99	i::Integer,
100	j::Integer,
101	k::Integer,
102	variables::Chi,
103	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
104	)::AbstractFloat
105	```
106
107	Return the tracer flux convergence due to gravity waves.
108
109	# Arguments
110
111	- `state`: Model state.
112
113	- `i`: Zonal grid-cell index.
114
115	- `j`: Meridional grid-cell index.
116
117	- `k`: Vertical grid-cell index.
118
119	- `variable`: Variable (equation) of choice.
120
121	- `wkb_mode`: Approximations used by MSGWaM.
122
123	# See also
124
125	- [`PinCFlow.Update.conductive_heating`](@ref)
126	"""
127	function compute_volume_force end
128
129	function compute_volume_force(	2,092,800✔
130	state::State,
131	i::Integer,
132	j::Integer,
133	k::Integer,
134	variable::Union{U, V, W, P, Chi},
135	)::AbstractFloat
136	(; wkb_mode) = state.namelists.wkb	2,092,800✔
137
138	return compute_volume_force(state, i, j, k, variable, wkb_mode)	2,092,800✔
139	end
140
141	function compute_volume_force(	1,102,600✔
142	state::State,
143	i::Integer,
144	j::Integer,
145	k::Integer,
146	variable::Union{U, V, W, Chi},
147	wkb_mode::NoWKB,
148	)::AbstractFloat
149	return 0.0	1,102,600✔
150	end
151
152	function compute_volume_force(	85,800✔
153	state::State,
154	i::Integer,
155	j::Integer,
156	k::Integer,
157	variable::U,
158	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
159	)::AbstractFloat
160	(; dudt) = state.wkb.tendencies	85,800✔
161
162	@ivy return (dudt[i, j, k] + dudt[i + 1, j, k]) / 2	85,800✔
163	end
164
165	function compute_volume_force(	85,800✔
166	state::State,
167	i::Integer,
168	j::Integer,
169	k::Integer,
170	variable::V,
171	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
172	)::AbstractFloat
173	(; dvdt) = state.wkb.tendencies	85,800✔
174
175	@ivy return (dvdt[i, j, k] + dvdt[i, j + 1, k]) / 2	85,800✔
176	end
177
178	function compute_volume_force(	174,200✔
179	state::State,
180	i::Integer,
181	j::Integer,
182	k::Integer,
183	variable::W,
184	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
185	)::AbstractFloat
186	(; jac, met) = state.grid	174,200✔
187	(; dudt, dvdt) = state.wkb.tendencies	174,200✔
188
189	@ivy return (	174,200✔
190	jac[i, j, k + 1] * (
191	met[i, j, k, 1, 3] * dudt[i, j, k] +
192	met[i, j, k, 2, 3] * dvdt[i, j, k]
193	) +
194	jac[i, j, k] * (
195	met[i, j, k + 1, 1, 3] * dudt[i, j, k + 1] +
196	met[i, j, k + 1, 2, 3] * dvdt[i, j, k + 1]
197	)
198	) / (jac[i, j, k] + jac[i, j, k + 1])
199	end
200
201	function compute_volume_force(	488,400✔
202	state::State,
203	i::Integer,
204	j::Integer,
205	k::Integer,
206	variable::P,
207	wkb_mode::NoWKB,
208	)::AbstractFloat
209	return conductive_heating(state, i, j, k)	488,400✔
210	end
211
212	function compute_volume_force(	156,000✔
213	state::State,
214	i::Integer,
215	j::Integer,
216	k::Integer,
217	variable::P,
218	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
219	)::AbstractFloat
220	(; dthetadt) = state.wkb.tendencies	156,000✔
221
222	@ivy return dthetadt[i, j, k] + conductive_heating(state, i, j, k)	156,000✔
223	end
224
225	function compute_volume_force(	×
226	state::State,
227	i::Integer,
228	j::Integer,
229	k::Integer,
230	variables::Chi,
231	wkb_mode::Union{SteadyState, SingleColumn, MultiColumn},
232	)::AbstractFloat
233	(; leading_order_impact) = state.namelists.tracer	×
234	(; chiq0) = state.tracer.tracerforcings	×
NEW 235	(; model) = state.namelists.atmosphere	×
236
237	@ivy if leading_order_impact && model == Compressible()	×
238	return chiq0.dchidt[i, j, k]	×
239	else
240	return 0.0	×
241	end
242	end

Atmospheric-Dynamics-GUF / PinCFlow.jl / 18561934460

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