fix: remove allocations in P3 scheme

Author: haakon-e

src/IceNucleation.jl

@@ -150,7 +150,7 @@ function P3_deposition_N_i(ip::CMP.MorrisonMilbrandt2014, T::FT) where {FT}
         max(FT(0), FT(ip.c₁ * exp(ip.c₂ * (T₀ - T_thres)))),
         max(FT(0), FT(ip.c₁ * exp(ip.c₂ * (T₀ - T)))),
     )
-    return Nᵢ * 1e3  # converts L^-1 to m^-3
+    return Nᵢ * 1000  # converts L^-1 to m^-3
 end
 
 """
@@ -176,9 +176,9 @@ function P3_het_N_i(
     Δt::FT,
 ) where {FT}
 
-    a = ip.het_a                # (celcius)^-1
-    B = ip.het_B                # cm^-3 s^-1 for rain water
-    V_l_converted = V_l * 1e6   # converted from m^3 to cm^3
+    a = ip.het_a                     # (celcius)^-1
+    B = ip.het_B                     # cm^-3 s^-1 for rain water
+    V_l_converted = V_l * 1_000_000  # converted from m^3 to cm^3
     Tₛ = ip.T₀ - T
 
     return N_l * (1 - exp(-B * V_l_converted * Δt * exp(a * Tₛ)))

src/P3_integral_properties.jl

@@ -34,7 +34,7 @@
 
 # Arguments
  - `f`: Function to integrate
- - `a`, `b`: Integration bounds
+ - `a`, `b`: Integration bounds. Note: if `a ≥ b`, we return zero.
 
 # Keyword arguments
  - `quad`: Quadrature scheme, default: `ChebyshevGauss(100)`
@@ -55,8 +55,9 @@ function integrate(f, a, b; quad = ChebyshevGauss(100))
     shift = (a + b) / 2
 
     # Compute integral using Chebyshev-Gauss quadrature
+    isnan(a) || isnan(b) && return FT(NaN)  # return NaN if any bound is NaN
     result = zero(f(a))
-    a == b && return result  # return early if a == b
+    a < b || return result  # return early unless a < b
     (; n) = quad
     for i in 1:n
         # Node on [-1, 1] interval
@@ -164,17 +165,15 @@ Compute the integration bounds for the P3 size distribution,
 - `bnds`: The integration bounds (a `Tuple`), for use in [`QGK.quadgk`].
 """
 function integral_bounds(state::P3State{FT}, logλ; p, moment_order = 0) where {FT}
-    # Get mass thresholds
-    (; D_th, D_gr, D_cr) = get_thresholds_ρ_g(state)
-    # Get bounds from quantiles
+    # Get reduced lower and upper bounds from quantiles
     k = get_μ(state, logλ) + moment_order
     D_min = DT.generalized_gamma_quantile(k, FT(1), exp(logλ), FT(p))
     D_max = DT.generalized_gamma_quantile(k, FT(1), exp(logλ), FT(1 - p))
 
     # Only integrate up to the maximum diameter, `D_max`, including intermediate thresholds
     # If `F_rim` is very close to 1, `D_cr` may be greater than `D_max`, in which case it is disregarded.
-    bnds = (D_min, filter(<(D_max), (D_th, D_gr, D_cr))..., D_max)
-    return bnds
+    thresholds = get_bounded_thresholds(state, D_min, D_max)
+    return thresholds
 end
 
 """

src/P3_particle_properties.jl

@@ -217,28 +217,29 @@ function get_thresholds_ρ_g(params::CMP.ParametersP3, F_rim, ρ_rim)
     return (; D_th, D_gr, D_cr, ρ_g)
 end
 
+function get_bounded_thresholds(state::P3State, D_min = 0, D_max = Inf)
+    FT = eltype(state)
+    (; D_th, D_gr, D_cr) = get_thresholds_ρ_g(state)
+    return clamp.((FT(D_min), D_th, D_gr, D_cr, FT(D_max)), FT(D_min), FT(D_max))
+end
+
 """
     get_segments(state::P3State)
 
-Return the segments of the size distribution.
+Return the segments of the size distribution as a tuple of intervals.
 
 # Arguments
 - `state`: [`P3State`](@ref) object
 
 # Returns
 - `segments`: tuple of tuples, each containing the lower and upper bounds of a segment
 
-For example, if the (valid) thresholds are `(D_th, D_gr, D_cr)`, then the segments are:
+For example, if the thresholds are `(D_th, D_gr, D_cr)`, then the segments are:
 - `(0, D_th)`, `(D_th, D_gr)`, `(D_gr, D_cr)`, `(D_cr, Inf)`
 """
-function get_segments(state::P3State)
-    FT = eltype(state)
-    (; D_th, D_gr, D_cr) = get_thresholds_ρ_g(state)
-    # For certain high rimed values, D_gr < D_th (cf test/p3_tests.jl):
-    #   so here we filter away invalid thresholds
-    # (this also works correctly for the unrimed case, where D_gr = D_cr = NaN)
-    valid_D = filter(≥(D_th), (D_th, D_gr, D_cr))
-    segments = tuple.((FT(0), valid_D...), (valid_D..., FT(Inf)))
+function get_segments(state::P3State, D_min = 0, D_max = Inf)
+    thresholds = get_bounded_thresholds(state, D_min, D_max)
+    segments = tuple.(Base.front(thresholds), Base.tail(thresholds))
     return segments
 end
 
@@ -300,9 +301,9 @@ Return the mass of a particle based on where it falls in the particle-size-based
  - `params, F_rim, ρ_rim`: The [`CMP.ParametersP3`](@ref), rime mass fraction, and rime density,
  - `D`: maximum particle dimension [m]
 """
-function ice_mass(args_D...)
-    D = last(args_D)
-    (a, b) = ice_mass_coeffs(args_D...)
+ice_mass((; params, F_rim, ρ_rim)::P3State, D) = ice_mass(params, F_rim, ρ_rim, D)
+function ice_mass(params::CMP.ParametersP3, F_rim, ρ_rim, D)
+    (a, b) = ice_mass_coeffs(params, F_rim, ρ_rim, D)
     return a * D^b
 end
 
@@ -322,13 +323,14 @@ Return the density of a particle at diameter D
  by the volume of a sphere with the same D [MorrisonMilbrandt2015](@cite).
  Needed for aspect ratio calculation, so we assume zero liquid fraction.
 """
-function ice_density(args_D...)
-    D = last(args_D)
-    return ice_mass(args_D...) / CO.volume_sphere_D(D)
+ice_density((; params, F_rim, ρ_rim)::P3State, D) = ice_density(params, F_rim, ρ_rim, D)
+function ice_density(params::CMP.ParametersP3, F_rim, ρ_rim, D)
+    return ice_mass(params, F_rim, ρ_rim, D) / CO.volume_sphere_D(D)
 end
 
-function get_∂mass_∂D_coeffs(args_D...)
-    (a, b) = ice_mass_coeffs(args_D...)
+get_∂mass_∂D_coeffs((; params, F_rim, ρ_rim)::P3State, D) = get_∂mass_∂D_coeffs(params, F_rim, ρ_rim, D)
+function get_∂mass_∂D_coeffs(params::CMP.ParametersP3, F_rim, ρ_rim, D)
+    (a, b) = ice_mass_coeffs(params, F_rim, ρ_rim, D)
     return a * b, b - 1
 end
 
@@ -338,9 +340,9 @@ end
 
 Return the derivative of the ice mass with respect to the particle diameter.
 """
-function ∂ice_mass_∂D(args_D...)
-    D = last(args_D)
-    (a, b) = get_∂mass_∂D_coeffs(args_D...)
+∂ice_mass_∂D((; params, F_rim, ρ_rim)::P3State, D) = ∂ice_mass_∂D(params, F_rim, ρ_rim, D)
+function ∂ice_mass_∂D(params::CMP.ParametersP3, F_rim, ρ_rim, D)
+    (a, b) = get_∂mass_∂D_coeffs(params, F_rim, ρ_rim, D)
     return a * D^b
 end
 
@@ -391,18 +393,18 @@ Returns the aspect ratio (ϕ) for an ice particle
  divided by the volume of a spherical particle with the same D_max [MorrisonMilbrandt2015](@cite).
  Assuming zero liquid fraction and oblate shape.
 """
-function ϕᵢ(args_D...)
-    D = last(args_D)
+ϕᵢ((; params, F_rim, ρ_rim)::P3State, D) = ϕᵢ(params, F_rim, ρ_rim, D)
+function ϕᵢ(params::CMP.ParametersP3, F_rim, ρ_rim, D)
     FT = eltype(D)
-    mᵢ = ice_mass(args_D...)
-    aᵢ = ice_area(args_D...)
-    ρᵢ = ice_density(args_D...)
+    mᵢ = ice_mass(params, F_rim, ρ_rim, D)
+    aᵢ = ice_area(params, F_rim, ρ_rim, D)
+    ρᵢ = ice_density(params, F_rim, ρ_rim, D)
 
     # TODO - prolate or oblate?
     ϕ_ob = min(1, 3 * sqrt(FT(π)) * mᵢ / (4 * ρᵢ * aᵢ^FT(1.5))) # κ =  1/3
     #ϕ_pr = max(1, 16 * ρᵢ^2 * aᵢ^3 / (9 * FT(π) * mᵢ^2))       # κ = -1/6
 
-    return ifelse(D == 0, 0, ϕ_ob)
+    return ifelse(D == 0, FT(0), ϕ_ob)
 end
 
 ### ----------------- ###