From 1613f495190e4a6145cb4b5e7ad9b436d8fb85e9 Mon Sep 17 00:00:00 2001 From: Anna Jaruga Date: Fri, 18 Aug 2023 16:54:26 -0700 Subject: [PATCH] Move ice nucleation J params to CLIMAParams --- Project.toml | 2 +- docs/Project.toml | 2 + docs/src/IceNucleation.md | 22 +++---- parcel/Project.toml | 2 + src/Common.jl | 33 +++++++--- src/IceNucleation.jl | 70 +++++++++++++--------- src/Parameters.jl | 22 +++++++ test/common_functions_tests.jl | 16 ++--- test/gpu_tests.jl | 18 +++--- test/heterogeneous_ice_nucleation_tests.jl | 12 +++- test/homogeneous_ice_nucleation_tests.jl | 15 ++--- test/performance_tests.jl | 6 +- 12 files changed, 142 insertions(+), 78 deletions(-) diff --git a/Project.toml b/Project.toml index a52b5562c8..db52f01e2e 100644 --- a/Project.toml +++ b/Project.toml @@ -14,7 +14,7 @@ SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" Thermodynamics = "b60c26fb-14c3-4610-9d3e-2d17fe7ff00c" [compat] -CLIMAParameters = ">=0.7.9" +CLIMAParameters = ">=0.7.12" CUDAKernels = "0.4" DocStringExtensions = "0.8, 0.9" ForwardDiff = "0.10" diff --git a/docs/Project.toml b/docs/Project.toml index 647a371981..5e2275fb09 100644 --- a/docs/Project.toml +++ b/docs/Project.toml @@ -7,3 +7,5 @@ DocumenterCitations = "daee34ce-89f3-4625-b898-19384cb65244" OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" Plots = "91a5bcdd-55d7-5caf-9e0b-520d859cae80" Thermodynamics = "b60c26fb-14c3-4610-9d3e-2d17fe7ff00c" +[compat] +CLIMAParameters = ">=0.7.12" diff --git a/docs/src/IceNucleation.md b/docs/src/IceNucleation.md index 9d34a484ba..1e8462987e 100644 --- a/docs/src/IceNucleation.md +++ b/docs/src/IceNucleation.md @@ -8,7 +8,7 @@ The parameterization for deposition on dust particles is an implementation of the empirical formulae from [Mohler2006](@cite) and is valid for two types of dust particles: Arizona Test Dust and desert dust from Sahara. - The parameterization for immersion freezing is an implementation of [KnopfAlpert2013](@cite) + The parameterization for immersion freezing is an implementation of [KnopfAlpert2013](@cite) and is valid for droplets containing sulphuric acid. !!! note @@ -45,16 +45,16 @@ Both parameters are dependent on aerosol properties and temperature. (either a second deposition or other condensation type mode). ## ABIFM for Sulphuric Acid Containing Droplets -Water Activity-Based Immersion Freezing Model (ABFIM) +Water Activity-Based Immersion Freezing Model (ABFIM) is a method of parameterizing immersion freezing inspired by the time-dependent - classical nucleation theory (CNT). More on CNT can be found in [Karthika2016](@cite). - The nucleation rate coefficient, ``J``, describes the number of ice nuclei formed per unit area + classical nucleation theory (CNT). More on CNT can be found in [Karthika2016](@cite). + The nucleation rate coefficient, ``J``, describes the number of ice nuclei formed per unit area per unit time and can be determined by the water activity, ``a_w``. This parameterization follows [KnopfAlpert2013](@cite), [Koop2002](@cite), [MurphyKoop2005](@cite), and [Luo1995](@cite). In this model, aerosols are assumed to contain an insoluble and soluble material. When immersed in water, the soluble material diffuses into the liquid water to create a sulphuric acid solution. -Using empirical coefficients, ``m`` and ``c``, from [KnopfAlpert2013](@cite), +Using empirical coefficients, ``m`` and ``c``, from [KnopfAlpert2013](@cite), the heterogeneous nucleation rate coefficient in units of ``cm^{-2}s^{-1}`` can be determined by the linear equation ```math \begin{equation} @@ -63,10 +63,10 @@ Using empirical coefficients, ``m`` and ``c``, from [KnopfAlpert2013](@cite), ``` !!! note - Our source code for the nucleation rate coefficient returns + Our source code for the nucleation rate coefficient returns ``J`` in base SI units. -``\Delta a_w``is the difference between the water activity of the droplet, ``a_w``, and the water activity of ice at the same temperature, ``a_{w,ice}(T)``. From [Koop2002](@cite), +``\Delta a_w``is the difference between the water activity of the droplet, ``a_w``, and the water activity of ice at the same temperature, ``a_{w,ice}(T)``. From [Koop2002](@cite), ```math \begin{equation} a_w = \frac{p_{sol}}{p_{sat}} @@ -96,8 +96,8 @@ Once ``J_{het}`` is calculated, it can be used to determine the ice production r P_{ice} = J_{het}A(N_{tot}-N_{ice}) \end{equation} ``` -where ``A`` is surface area of an individual ice nuclei, ``N_{tot}`` is total number - of ice nuclei, and ``N_{ice}`` is number of ice crystals already in the system. +where ``A`` is surface area of an individual ice nuclei, ``N_{tot}`` is total number + of ice nuclei, and ``N_{ice}`` is number of ice crystals already in the system. ## Homogeneous Freezing for Sulphuric Acid Containing Droplets Homogeneous freezing occurs when supercooled liquid droplets freeze on their own. @@ -144,13 +144,13 @@ Delta_a = Vector{Float64}(undef, length(temp)) J = Vector{Float64}(undef, length(temp)) # Knopf and Alpert 2013 Figure 4A -# https://doi.org/10.1039/C3FD00035D +# https://doi.org/10.1039/C3FD00035D dust_type = CT.KaoliniteType() it = 1 for T in temp Delta_a[it] = CO.Delta_a_w(prs, x, T) - J[it] = IN.ABIFM_J(dust_type, Delta_a[it]) + J[it] = IN.ABIFM_J(prs, dust_type, Delta_a[it]) global it += 1 end log10J_converted = @. log10(J*1e-4) diff --git a/parcel/Project.toml b/parcel/Project.toml index ad7d47e792..d50d0d0ff8 100644 --- a/parcel/Project.toml +++ b/parcel/Project.toml @@ -8,3 +8,5 @@ KernelAbstractions = "63c18a36-062a-441e-b654-da1e3ab1ce7c" OrdinaryDiffEq = "1dea7af3-3e70-54e6-95c3-0bf5283fa5ed" Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40" Thermodynamics = "b60c26fb-14c3-4610-9d3e-2d17fe7ff00c" +[compat] +CLIMAParameters = ">=0.7.12" diff --git a/src/Common.jl b/src/Common.jl index b1a81f1617..25d51265eb 100644 --- a/src/Common.jl +++ b/src/Common.jl @@ -124,24 +124,41 @@ function logistic_function_integral(x::FT, x_0::FT, k::FT) where {FT <: Real} end """ - H2SO4_soln_saturation_vapor_pressure(x, T) + H2SO4_soln_saturation_vapor_pressure(prs, x, T) + - `prs` - a set with free parameters - `x` - wt percent sulphuric acid [unitless] - `T` - air temperature [K]. Returns the saturation vapor pressure above a sulphuric acid solution droplet in Pa. `x` is, for example, 0.1 if droplets are 10 percent sulphuric acid by weight """ -function H2SO4_soln_saturation_vapor_pressure(x::FT, T::FT) where {FT <: Real} +function H2SO4_soln_saturation_vapor_pressure( + prs::APS, + x::FT, + T::FT, +) where {FT <: Real} + + T_max::FT = CMP.H2SO4_sol_T_max(prs) + T_min::FT = CMP.H2SO4_sol_T_min(prs) + w_2::FT = CMP.H2SO4_sol_w_2(prs) + + c1::FT = CMP.H2SO4_sol_c1(prs) + c2::FT = CMP.H2SO4_sol_c2(prs) + c3::FT = CMP.H2SO4_sol_c3(prs) + c4::FT = CMP.H2SO4_sol_c4(prs) + c5::FT = CMP.H2SO4_sol_c5(prs) + c6::FT = CMP.H2SO4_sol_c6(prs) + c7::FT = CMP.H2SO4_sol_c7(prs) - @assert T < FT(235) - @assert T > FT(185) + @assert T < T_max + @assert T > T_min - w_h = 1.4408 * x + w_h = w_2 * x p_sol = exp( - 23.306 - 5.3465 * x + 12 * x * w_h - 8.19 * x * w_h^2 + - (-5814 + 928.9 * x - 1876.7 * x * w_h) / T, + c1 - c2 * x + c3 * x * w_h - c4 * x * w_h^2 + + (c5 + c6 * x - c7 * x * w_h) / T, ) * 100 # * 100 converts mbar --> Pa return p_sol end @@ -160,7 +177,7 @@ function Delta_a_w(prs::APS, x::FT, T::FT) where {FT <: Real} thermo_params = CMP.thermodynamics_params(prs) - p_sol = H2SO4_soln_saturation_vapor_pressure(x, T) + p_sol = H2SO4_soln_saturation_vapor_pressure(prs, x, T) p_sat = TD.saturation_vapor_pressure(thermo_params, T, TD.Liquid()) p_ice = TD.saturation_vapor_pressure(thermo_params, T, TD.Ice()) diff --git a/src/IceNucleation.jl b/src/IceNucleation.jl index 9022dd0c5d..2759240177 100644 --- a/src/IceNucleation.jl +++ b/src/IceNucleation.jl @@ -22,14 +22,12 @@ S0_cold(prs::APS, ::CT.DesertDustType) = CMP.S0_cold_DD_Mohler2006(prs) a_warm(prs::APS, ::CT.DesertDustType) = CMP.a_warm_DD_Mohler2006(prs) a_cold(prs::APS, ::CT.DesertDustType) = CMP.a_cold_DD_Mohler2006(prs) -J_het_coeff_m(::CT.DesertDustType) = 22.62 -J_het_coeff_c(::CT.DesertDustType) = -1.35 - -J_het_coeff_m(::CT.KaoliniteType) = 54.58834 -J_het_coeff_c(::CT.KaoliniteType) = -10.54758 - -J_het_coeff_m(::CT.IlliteType) = 54.48075 -J_het_coeff_c(::CT.IlliteType) = -10.66873 +J_het_m(prs::APS, ::CT.DesertDustType) = CMP.J_ABIFM_m_KA2013_DesertDust(prs) +J_het_c(prs::APS, ::CT.DesertDustType) = CMP.J_ABIFM_c_KA2013_DesertDust(prs) +J_het_m(prs::APS, ::CT.KaoliniteType) = CMP.J_ABIFM_m_KA2013_Kaolinite(prs) +J_het_c(prs::APS, ::CT.KaoliniteType) = CMP.J_ABIFM_c_KA2013_Kaolinite(prs) +J_het_m(prs::APS, ::CT.IlliteType) = CMP.J_ABIFM_m_KA2013_Illite(prs) +J_het_c(prs::APS, ::CT.IlliteType) = CMP.J_ABIFM_c_KA2013_Illite(prs) """ dust_activated_number_fraction(prs, Si, T, dust_type) @@ -66,23 +64,31 @@ function dust_activated_number_fraction( end """ - ABIFM_J(dust_type, Δa_w) + ABIFM_J(prs, dust_type, Δa_w) - - `dust_type` - choosing aerosol type + - `prs` - set with free parameters + - `dust_type` - aerosol type - `Δa_w` - change in water activity [unitless]. -Returns the immersion freezing nucleation rate coefficient, `J`, in m^-2 s^-1 for sulphuric acid containing solutions. -For other solutions, p_sol should be adjusted accordingly. Delta_a_w can be found using the Delta_a_w function in Common.jl. -`m` and `c` constants are taken from Knopf & Alpert 2013. +Returns the immersion freezing nucleation rate coefficient, `J`, in m^-2 s^-1 +for sulphuric acid solutions. +For other solutions, p_sol should be adjusted accordingly. +Delta_a_w can be found using the Delta_a_w function in Common.jl. +The free parameters `m` and `c` are taken from Knopf & Alpert 2013 +see DOI: 10.1039/C3FD00035D """ -function ABIFM_J(dust_type::CT.AbstractAerosolType, Δa_w::FT) where {FT <: Real} +function ABIFM_J( + prs::APS, + dust_type::CT.AbstractAerosolType, + Δa_w::FT, +) where {FT <: Real} - m = J_het_coeff_m(dust_type) - c = J_het_coeff_c(dust_type) + m::FT = J_het_m(prs, dust_type) + c::FT = J_het_c(prs, dust_type) - logJ = m * Δa_w + c + logJ::FT = m * Δa_w + c - return max(0, 10^logJ * 100^2) # converts cm^-2 s^-1 to m^-2 s^-1 + return max(FT(0), FT(10)^logJ * FT(1e4)) # converts cm^-2 s^-1 to m^-2 s^-1 end end # end module @@ -101,23 +107,31 @@ const APS = CMP.AbstractCloudMicrophysicsParameters export homogeneous_J """ - homogeneous_J(Δa_w) + homogeneous_J(prs, Δa_w) - - `Δa_w` - change in water activity + - `prs` - a set with free parameters + - `Δa_w` - change in water activity [-]. -Returns the homogeneous freezing nucleation rate coefficient, `J`, in m^-3 s^-1 for sulphuric -acid containing solutions. Parameterization based off Koop 2000. +Returns the homogeneous freezing nucleation rate coefficient, +`J`, in m^-3 s^-1 for sulphuric acid solutions. +Parameterization based on Koop 2000, DOI: 10.1038/35020537. Delta_a_w can be found using the Delta_a_w function in Common.jl. """ -function homogeneous_J(Δa_w::FT) where {FT <: Real} +function homogeneous_J(prs::APS, Δa_w::FT) where {FT <: Real} + + Δa_w_min::FT = CMP.Koop2000_min_delta_aw(prs) + Δa_w_max::FT = CMP.Koop2000_max_delta_aw(prs) + c1::FT = CMP.Koop2000_J_hom_c1(prs) + c2::FT = CMP.Koop2000_J_hom_c2(prs) + c3::FT = CMP.Koop2000_J_hom_c3(prs) + c4::FT = CMP.Koop2000_J_hom_c4(prs) - @assert Δa_w > 0.26 - @assert Δa_w < 0.34 + @assert Δa_w > Δa_w_min + @assert Δa_w < Δa_w_max - logJ = -906.7 + 8502 * Δa_w - 26924 * Δa_w^2 + 29180 * Δa_w^3 - J = 10^(logJ) + logJ::FT = c1 + c2 * Δa_w - c3 * Δa_w^2 + c4 * Δa_w^3 - return J * 1e6 + return FT(10)^(logJ) * 1e6 end end # end module diff --git a/src/Parameters.jl b/src/Parameters.jl index f8d0d5bdd9..f6499177bf 100644 --- a/src/Parameters.jl +++ b/src/Parameters.jl @@ -164,6 +164,28 @@ Base.@kwdef struct CloudMicrophysicsParameters{FT, TP} <: S0_cold_DD_Mohler2006::FT a_warm_DD_Mohler2006::FT a_cold_DD_Mohler2006::FT + J_ABIFM_m_KA2013_DesertDust::FT + J_ABIFM_c_KA2013_DesertDust::FT + J_ABIFM_m_KA2013_Kaolinite::FT + J_ABIFM_c_KA2013_Kaolinite::FT + J_ABIFM_m_KA2013_Illite::FT + J_ABIFM_c_KA2013_Illite::FT + Koop2000_min_delta_aw::FT + Koop2000_max_delta_aw::FT + Koop2000_J_hom_c1::FT + Koop2000_J_hom_c2::FT + Koop2000_J_hom_c3::FT + Koop2000_J_hom_c4::FT + H2SO4_sol_T_max::FT + H2SO4_sol_T_min::FT + H2SO4_sol_w_2::FT + H2SO4_sol_c1::FT + H2SO4_sol_c2::FT + H2SO4_sol_c3::FT + H2SO4_sol_c4::FT + H2SO4_sol_c5::FT + H2SO4_sol_c6::FT + H2SO4_sol_c7::FT molmass_seasalt::FT rho_seasalt::FT osm_coeff_seasalt::FT diff --git a/test/common_functions_tests.jl b/test/common_functions_tests.jl index c78105e6a6..81678fd218 100644 --- a/test/common_functions_tests.jl +++ b/test/common_functions_tests.jl @@ -63,18 +63,20 @@ function test_H2SO4_soln_saturation_vapor_pressure(FT) x_sulph = FT(0.1) # If T out of range - TT.@test_throws AssertionError("T < FT(235)") CO.H2SO4_soln_saturation_vapor_pressure( + TT.@test_throws AssertionError("T < T_max") CO.H2SO4_soln_saturation_vapor_pressure( + prs, x_sulph, T_too_warm, ) - TT.@test_throws AssertionError("T > FT(185)") CO.H2SO4_soln_saturation_vapor_pressure( + TT.@test_throws AssertionError("T > T_min") CO.H2SO4_soln_saturation_vapor_pressure( + prs, x_sulph, T_too_cold, ) # p_sol should be higher at warmer temperatures - TT.@test CO.H2SO4_soln_saturation_vapor_pressure(x_sulph, T_warm) > - CO.H2SO4_soln_saturation_vapor_pressure(x_sulph, T_cold) + TT.@test CO.H2SO4_soln_saturation_vapor_pressure(prs, x_sulph, T_warm) > + CO.H2SO4_soln_saturation_vapor_pressure(prs, x_sulph, T_cold) end end @@ -97,15 +99,9 @@ end println("Testing Float64") test_H2SO4_soln_saturation_vapor_pressure(Float64) - - println("Testing Float32") test_H2SO4_soln_saturation_vapor_pressure(Float32) - - println("Testing Float64") test_Delta_a_w(Float64) - - println("Testing Float32") test_Delta_a_w(Float32) diff --git a/test/gpu_tests.jl b/test/gpu_tests.jl index 7b206ee33c..6ca3215eb5 100644 --- a/test/gpu_tests.jl +++ b/test/gpu_tests.jl @@ -270,6 +270,7 @@ end end @kernel function test_Common_H2SO4_soln_saturation_vapor_pressure_kernel!( + prs, output::AbstractArray{FT}, x_sulph, T, @@ -278,7 +279,8 @@ end i = @index(Group, Linear) @inbounds begin - output[i] = CO.H2SO4_soln_saturation_vapor_pressure(x_sulph[i], T[i]) + output[i] = + CO.H2SO4_soln_saturation_vapor_pressure(prs, x_sulph[i], T[i]) end end @@ -297,6 +299,7 @@ end end @kernel function test_IceNucleation_ABIFM_J_kernel!( + prs, output::AbstractArray{FT}, Delta_a_w, ) where {FT} @@ -304,12 +307,13 @@ end i = @index(Group, Linear) @inbounds begin - output[1] = CMI_het.ABIFM_J(kaolinite, Delta_a_w[1]) - output[2] = CMI_het.ABIFM_J(illite, Delta_a_w[2]) + output[1] = CMI_het.ABIFM_J(prs, kaolinite, Delta_a_w[1]) + output[2] = CMI_het.ABIFM_J(prs, illite, Delta_a_w[2]) end end @kernel function test_IceNucleation_homogeneous_J_kernel!( + prs, output::AbstractArray{FT}, Delta_a_w, ) where {FT} @@ -317,7 +321,7 @@ end i = @index(Group, Linear) @inbounds begin - output[1] = CMI_hom.homogeneous_J(Delta_a_w[1]) + output[1] = CMI_hom.homogeneous_J(prs, Delta_a_w[1]) end end @@ -582,7 +586,7 @@ function test_gpu(FT) dev, work_groups, ) - event = kernel!(output, x_sulph, T, ndrange = ndrange) + event = kernel!(make_prs(FT), output, x_sulph, T, ndrange = ndrange) wait(dev, event) # test H2SO4_soln_saturation_vapor_pressure is callable and returns a reasonable value @@ -619,7 +623,7 @@ function test_gpu(FT) Delta_a_w = ArrayType([FT(0.16), FT(0.15)]) kernel! = test_IceNucleation_ABIFM_J_kernel!(dev, work_groups) - event = kernel!(output, Delta_a_w, ndrange = ndrange) + event = kernel!(make_prs(FT), output, Delta_a_w, ndrange = ndrange) wait(dev, event) # test if ABIFM_J is callable and returns reasonable values @@ -639,7 +643,7 @@ function test_gpu(FT) Delta_a_w = ArrayType([FT(0.2907389666103033)]) kernel! = test_IceNucleation_homogeneous_J_kernel!(dev, work_groups) - event = kernel!(output, Delta_a_w, ndrange = ndrange) + event = kernel!(make_prs(FT), output, Delta_a_w, ndrange = ndrange) wait(dev, event) # test homogeneous_J is callable and returns a reasonable value diff --git a/test/heterogeneous_ice_nucleation_tests.jl b/test/heterogeneous_ice_nucleation_tests.jl index e7567a36d6..2b6db419c1 100644 --- a/test/heterogeneous_ice_nucleation_tests.jl +++ b/test/heterogeneous_ice_nucleation_tests.jl @@ -87,8 +87,15 @@ function test_heterogeneous_ice_nucleation(FT) # higher nucleation rate at colder temperatures for dust in [CMT.IlliteType(), CMT.KaoliniteType(), CMT.DesertDustType()] - TT.@test CMI_het.ABIFM_J(dust, CO.Delta_a_w(prs, x_sulph, T_cold)) > - CMI_het.ABIFM_J(dust, CO.Delta_a_w(prs, x_sulph, T_warm)) + TT.@test CMI_het.ABIFM_J( + prs, + dust, + CO.Delta_a_w(prs, x_sulph, T_cold), + ) > CMI_het.ABIFM_J( + prs, + dust, + CO.Delta_a_w(prs, x_sulph, T_warm), + ) end end end @@ -96,6 +103,5 @@ end println("Testing Float64") test_heterogeneous_ice_nucleation(Float64) - println("Testing Float32") test_heterogeneous_ice_nucleation(Float32) diff --git a/test/homogeneous_ice_nucleation_tests.jl b/test/homogeneous_ice_nucleation_tests.jl index 676b7fd6f0..2fc48e5949 100644 --- a/test/homogeneous_ice_nucleation_tests.jl +++ b/test/homogeneous_ice_nucleation_tests.jl @@ -5,7 +5,7 @@ import CloudMicrophysics as CM import CLIMAParameters as CP const CO = CM.Common -const CMI_hom = CM.HomIceNucleation +const CMH = CM.HomIceNucleation include(joinpath(pkgdir(CM), "test", "create_parameters.jl")) @@ -23,24 +23,25 @@ function test_homogeneous_J(FT) Δa_w_too_small = FT(0.25) Δa_w_too_large = FT(0.35) + # higher nucleation rate at colder temperatures - TT.@test CMI_hom.homogeneous_J(CO.Delta_a_w(prs, x_sulph, T_cold)) > - CMI_hom.homogeneous_J(CO.Delta_a_w(prs, x_sulph, T_warm)) + TT.@test CMH.homogeneous_J(prs, CO.Delta_a_w(prs, x_sulph, T_cold)) > + CMH.homogeneous_J(prs, CO.Delta_a_w(prs, x_sulph, T_warm)) # If Δa_w out of range - TT.@test_throws AssertionError("Δa_w > 0.26") CMI_hom.homogeneous_J( + TT.@test_throws AssertionError("Δa_w > Δa_w_min") CMH.homogeneous_J( + prs, Δa_w_too_small, ) - TT.@test_throws AssertionError("Δa_w < 0.34") CMI_hom.homogeneous_J( + TT.@test_throws AssertionError("Δa_w < Δa_w_max") CMH.homogeneous_J( + prs, Δa_w_too_large, ) end end - println("Testing Float64") test_homogeneous_J(Float64) - println("Testing Float32") test_homogeneous_J(Float32) diff --git a/test/performance_tests.jl b/test/performance_tests.jl index b830407575..8d03bab51f 100644 --- a/test/performance_tests.jl +++ b/test/performance_tests.jl @@ -108,7 +108,7 @@ function benchmark_test(FT) # Common bench_press( CO.H2SO4_soln_saturation_vapor_pressure, - (x_sulph, T_air_cold), + (prs, x_sulph, T_air_cold), 50, ) bench_press(CO.Delta_a_w, (prs, x_sulph, T_air_cold), 230) @@ -119,8 +119,8 @@ function benchmark_test(FT) (prs, S_ice, T_air_2, dust), 50, ) - bench_press(CMI_het.ABIFM_J, (dust, Delta_a_w), 230) - bench_press(CMI_hom.homogeneous_J, (Delta_a_w), 230) + bench_press(CMI_het.ABIFM_J, (prs, dust, Delta_a_w), 230) + bench_press(CMI_hom.homogeneous_J, (prs, Delta_a_w), 230) # non-equilibrium bench_press(CMN.τ_relax, (prs, liquid), 10)