From 06aac2d3ac72fd1fcb7dd1e04b2892c90f26b6f7 Mon Sep 17 00:00:00 2001 From: nefrathenrici Date: Tue, 6 Feb 2024 17:42:43 -0800 Subject: [PATCH] Refactor parameters to use ClimaParameters API --- Project.toml | 4 +- docs/src/guides/Parameters.jl | 4 +- docs/src/plots/Thersholds_transitions.jl | 8 +- src/parameters/AerosolATD.jl | 24 +- src/parameters/AerosolActivation.jl | 26 +- src/parameters/AerosolDesertDust.jl | 28 +- src/parameters/AerosolFeldspar.jl | 20 +- src/parameters/AerosolFerrihydrite.jl | 20 +- src/parameters/AerosolIllite.jl | 19 +- src/parameters/AerosolKaolinite.jl | 24 +- src/parameters/AerosolModalNucleation.jl | 120 ++++---- src/parameters/AerosolSeasalt.jl | 28 +- src/parameters/AerosolSulfate.jl | 28 +- src/parameters/Aerosol_H2SO4_Solution.jl | 36 +-- src/parameters/AirProperties.jl | 22 +- src/parameters/IceNucleation.jl | 53 ++-- src/parameters/Microphysics0M.jl | 22 +- src/parameters/Microphysics1M.jl | 294 ++++++++++-------- src/parameters/Microphysics2M.jl | 362 ++++++++++++++--------- src/parameters/MicrophysicsP3.jl | 36 +-- src/parameters/TerminalVelocity.jl | 226 ++++++-------- src/parameters/WaterProperties.jl | 19 +- 22 files changed, 763 insertions(+), 660 deletions(-) diff --git a/Project.toml b/Project.toml index b062f57f0..9a3a18289 100644 --- a/Project.toml +++ b/Project.toml @@ -12,10 +12,10 @@ SpecialFunctions = "276daf66-3868-5448-9aa4-cd146d93841b" Thermodynamics = "b60c26fb-14c3-4610-9d3e-2d17fe7ff00c" [compat] -CLIMAParameters = "0.8" +CLIMAParameters = "0.8.6" DocStringExtensions = "0.8, 0.9" ForwardDiff = "0.10" RootSolvers = "0.3, 0.4" SpecialFunctions = "1, 2" -Thermodynamics = "0.9, 0.10, 0.11" +Thermodynamics = "0.11" julia = "1.6" diff --git a/docs/src/guides/Parameters.jl b/docs/src/guides/Parameters.jl index 203561c4f..5950bc498 100644 --- a/docs/src/guides/Parameters.jl +++ b/docs/src/guides/Parameters.jl @@ -39,7 +39,7 @@ open(override_file, "w") do io end toml_dict = CP.create_toml_dict(FT; override_file) isfile(override_file) && rm(override_file; force = true) -const overwrite = CMP.Rain(FT, toml_dict) +const overwrite = CMP.Rain(toml_dict) nothing #hide @@ -51,7 +51,7 @@ override_file = Dict( Dict("value" => 13, "type" => "float"), ) toml_dict2 = CP.create_toml_dict(FT; override_file) -const overwrite2 = CMP.Rain(FT, toml_dict2) +const overwrite2 = CMP.Rain(toml_dict2) nothing #hide diff --git a/docs/src/plots/Thersholds_transitions.jl b/docs/src/plots/Thersholds_transitions.jl index 99a4331c5..2b95ce7fe 100644 --- a/docs/src/plots/Thersholds_transitions.jl +++ b/docs/src/plots/Thersholds_transitions.jl @@ -27,10 +27,10 @@ for i in 1:3 toml_dict = CP.create_toml_dict(FT; override_file) isfile(override_file) && rm(override_file; force = true) - push!(rain, CMP.Rain(FT, toml_dict)) - push!(B1994, CMP.B1994(FT, toml_dict)) - push!(TC1980, CMP.TC1980(FT, toml_dict)) - push!(LD2004, CMP.LD2004(FT, toml_dict)) + push!(rain, CMP.Rain(toml_dict)) + push!(B1994, CMP.B1994(toml_dict)) + push!(TC1980, CMP.TC1980(toml_dict)) + push!(LD2004, CMP.LD2004(toml_dict)) end # example values diff --git a/src/parameters/AerosolATD.jl b/src/parameters/AerosolATD.jl index 17c92ff4b..08526e933 100644 --- a/src/parameters/AerosolATD.jl +++ b/src/parameters/AerosolATD.jl @@ -9,7 +9,7 @@ Mohler et al, 2006. DOI: 10.5194/acp-6-3007-2006 # Fields $(DocStringExtensions.FIELDS) """ -struct ArizonaTestDust{FT} <: AerosolType{FT} +Base.@kwdef struct ArizonaTestDust{FT} <: AerosolType{FT} "S₀ for T > T_thr [-]" S₀_warm::FT "S₀ for T < T_thr [-]" @@ -20,15 +20,17 @@ struct ArizonaTestDust{FT} <: AerosolType{FT} a_cold::FT end -function ArizonaTestDust( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return ArizonaTestDust( - FT(data["Mohler2006_S0_warm_ArizonaTestDust"]["value"]), - FT(data["Mohler2006_S0_cold_ArizonaTestDust"]["value"]), - FT(data["Mohler2006_a_warm_ArizonaTestDust"]["value"]), - FT(data["Mohler2006_a_cold_ArizonaTestDust"]["value"]), +ArizonaTestDust(::Type{FT}) where {FT <: AbstractFloat} = + ArizonaTestDust(CP.create_toml_dict(FT)) + +function ArizonaTestDust(td::CP.AbstractTOMLDict) + name_map = (; + :Mohler2006_S0_warm_ArizonaTestDust => :S₀_warm, + :Mohler2006_S0_cold_ArizonaTestDust => :S₀_cold, + :Mohler2006_a_warm_ArizonaTestDust => :a_warm, + :Mohler2006_a_cold_ArizonaTestDust => :a_cold, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return ArizonaTestDust{FT}(; parameters...) end diff --git a/src/parameters/AerosolActivation.jl b/src/parameters/AerosolActivation.jl index a0c6fc1f3..889891f86 100644 --- a/src/parameters/AerosolActivation.jl +++ b/src/parameters/AerosolActivation.jl @@ -9,7 +9,7 @@ DOI: 10.1029/1999JD901161 # Fields $(DocStringExtensions.FIELDS) """ -struct AerosolActivationParameters{FT} <: ParametersType{FT} +Base.@kwdef struct AerosolActivationParameters{FT} <: ParametersType{FT} "molar mass of water [kg/mol]" M_w::FT "gas constant [J/mol/K]" @@ -22,16 +22,18 @@ struct AerosolActivationParameters{FT} <: ParametersType{FT} g::FT end -function AerosolActivationParameters( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return AerosolActivationParameters( - FT(data["molar_mass_water"]["value"]), - FT(data["gas_constant"]["value"]), - FT(data["density_liquid_water"]["value"]), - FT(data["surface_tension_water"]["value"]), - FT(data["gravitational_acceleration"]["value"]), +AerosolActivationParameters(::Type{FT}) where {FT <: AbstractFloat} = + AerosolActivationParameters(CP.create_toml_dict(FT)) + +function AerosolActivationParameters(td::CP.AbstractTOMLDict) + name_map = (; + :molar_mass_water => :M_w, + :gas_constant => :R, + :density_liquid_water => :ρ_w, + :surface_tension_water => :σ, + :gravitational_acceleration => :g, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return AerosolActivationParameters{FT}(; parameters...) end diff --git a/src/parameters/AerosolDesertDust.jl b/src/parameters/AerosolDesertDust.jl index 14d904973..c413bb8f5 100644 --- a/src/parameters/AerosolDesertDust.jl +++ b/src/parameters/AerosolDesertDust.jl @@ -10,7 +10,7 @@ and from Mohler et al, 2006 DOI: 10.5194/acp-6-3007-2006 # Fields $(DocStringExtensions.FIELDS) """ -struct DesertDust{FT} <: AerosolType{FT} +Base.@kwdef struct DesertDust{FT} <: AerosolType{FT} "S₀ for T > T_thr [-]" S₀_warm::FT "S₀ for T < T_thr [-]" @@ -25,17 +25,19 @@ struct DesertDust{FT} <: AerosolType{FT} ABIFM_c::FT end -function DesertDust( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return DesertDust( - FT(data["Mohler2006_S0_warm_DesertDust"]["value"]), - FT(data["Mohler2006_S0_cold_DesertDust"]["value"]), - FT(data["Mohler2006_a_warm_DesertDust"]["value"]), - FT(data["Mohler2006_a_cold_DesertDust"]["value"]), - FT(data["AlpertKnopf2016_J_ABIFM_m_DesertDust"]["value"]), - FT(data["AlpertKnopf2016_J_ABIFM_c_DesertDust"]["value"]), +DesertDust(::Type{FT}) where {FT <: AbstractFloat} = + DesertDust(CP.create_toml_dict(FT)) + +function DesertDust(td::CP.AbstractTOMLDict) + name_map = (; + :Mohler2006_S0_warm_DesertDust => :S₀_warm, + :Mohler2006_S0_cold_DesertDust => :S₀_cold, + :Mohler2006_a_warm_DesertDust => :a_warm, + :Mohler2006_a_cold_DesertDust => :a_cold, + :AlpertKnopf2016_J_ABIFM_m_DesertDust => :ABIFM_m, + :AlpertKnopf2016_J_ABIFM_c_DesertDust => :ABIFM_c, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return DesertDust{FT}(; parameters...) end diff --git a/src/parameters/AerosolFeldspar.jl b/src/parameters/AerosolFeldspar.jl index 59125de44..6d072d9cd 100644 --- a/src/parameters/AerosolFeldspar.jl +++ b/src/parameters/AerosolFeldspar.jl @@ -9,20 +9,22 @@ DOI: 10.1039/D1EA00077B # Fields $(DocStringExtensions.FIELDS) """ -struct Feldspar{FT} <: AerosolType{FT} +Base.@kwdef struct Feldspar{FT} <: AerosolType{FT} "m coefficient for deposition nucleation J [-]" deposition_m::FT "c coefficient for deposition nucleation J [-]" deposition_c::FT end -function Feldspar( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Feldspar( - FT(data["Alpert2022_J_deposition_m_Feldspar"]["value"]), - FT(data["Alpert2022_J_deposition_c_Feldspar"]["value"]), +Feldspar(::Type{FT}) where {FT <: AbstractFloat} = + Feldspar(CP.create_toml_dict(FT)) + +function Feldspar(td::CP.AbstractTOMLDict) + name_map = (; + :Alpert2022_J_deposition_m_Feldspar => :deposition_m, + :Alpert2022_J_deposition_c_Feldspar => :deposition_c, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Feldspar{FT}(; parameters...) end diff --git a/src/parameters/AerosolFerrihydrite.jl b/src/parameters/AerosolFerrihydrite.jl index f1762383b..131fdc497 100644 --- a/src/parameters/AerosolFerrihydrite.jl +++ b/src/parameters/AerosolFerrihydrite.jl @@ -9,20 +9,22 @@ DOI: 10.1039/D1EA00077B # Fields $(DocStringExtensions.FIELDS) """ -struct Ferrihydrite{FT} <: AerosolType{FT} +Base.@kwdef struct Ferrihydrite{FT} <: AerosolType{FT} "m coefficient for deposition nucleation J [-]" deposition_m::FT "c coefficient for deposition nucleation J [-]" deposition_c::FT end -function Ferrihydrite( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Ferrihydrite( - FT(data["Alpert2022_J_deposition_m_Ferrihydrite"]["value"]), - FT(data["Alpert2022_J_deposition_c_Ferrihydrite"]["value"]), +Ferrihydrite(::Type{FT}) where {FT <: AbstractFloat} = + Ferrihydrite(CP.create_toml_dict(FT)) + +function Ferrihydrite(td::CP.AbstractTOMLDict) + name_map = (; + :Alpert2022_J_deposition_m_Ferrihydrite => :deposition_m, + :Alpert2022_J_deposition_c_Ferrihydrite => :deposition_c, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Ferrihydrite{FT}(; parameters...) end diff --git a/src/parameters/AerosolIllite.jl b/src/parameters/AerosolIllite.jl index bd7b79ff4..2730bc1e2 100644 --- a/src/parameters/AerosolIllite.jl +++ b/src/parameters/AerosolIllite.jl @@ -9,20 +9,21 @@ DOI: 10.1039/C3FD00035D # Fields $(DocStringExtensions.FIELDS) """ -struct Illite{FT} <: AerosolType{FT} +Base.@kwdef struct Illite{FT} <: AerosolType{FT} "m coefficient for immersion freezing J [-]" ABIFM_m::FT "c coefficient for immersion freezing J [-]" ABIFM_c::FT end -function Illite( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Illite( - FT(data["KnopfAlpert2013_J_ABIFM_m_Illite"]["value"]), - FT(data["KnopfAlpert2013_J_ABIFM_c_Illite"]["value"]), +Illite(::Type{FT}) where {FT <: AbstractFloat} = Illite(CP.create_toml_dict(FT)) + +function Illite(td::CP.AbstractTOMLDict) + name_map = (; + :KnopfAlpert2013_J_ABIFM_m_Illite => :ABIFM_m, + :KnopfAlpert2013_J_ABIFM_c_Illite => :ABIFM_c, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Illite{FT}(; parameters...) end diff --git a/src/parameters/AerosolKaolinite.jl b/src/parameters/AerosolKaolinite.jl index 3bc6af646..0b3a66b47 100644 --- a/src/parameters/AerosolKaolinite.jl +++ b/src/parameters/AerosolKaolinite.jl @@ -10,7 +10,7 @@ DOI: 10.1002/2016JD025817 # Fields $(DocStringExtensions.FIELDS) """ -struct Kaolinite{FT} <: AerosolType{FT} +Base.@kwdef struct Kaolinite{FT} <: AerosolType{FT} "m coefficient for deposition nucleation J [-]" deposition_m::FT "c coefficient for deposition nucleation J [-]" @@ -21,15 +21,17 @@ struct Kaolinite{FT} <: AerosolType{FT} ABIFM_c::FT end -function Kaolinite( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Kaolinite( - FT(data["China2017_J_deposition_m_Kaolinite"]["value"]), - FT(data["China2017_J_deposition_c_Kaolinite"]["value"]), - FT(data["KnopfAlpert2013_J_ABIFM_m_Kaolinite"]["value"]), - FT(data["KnopfAlpert2013_J_ABIFM_c_Kaolinite"]["value"]), +Kaolinite(::Type{FT}) where {FT <: AbstractFloat} = + Kaolinite(CP.create_toml_dict(FT)) + +function Kaolinite(td::CP.AbstractTOMLDict) + name_map = (; + :China2017_J_deposition_m_Kaolinite => :deposition_m, + :China2017_J_deposition_c_Kaolinite => :deposition_c, + :KnopfAlpert2013_J_ABIFM_m_Kaolinite => :ABIFM_m, + :KnopfAlpert2013_J_ABIFM_c_Kaolinite => :ABIFM_c, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Kaolinite{FT}(; parameters...) end diff --git a/src/parameters/AerosolModalNucleation.jl b/src/parameters/AerosolModalNucleation.jl index c207b3282..564955f3f 100644 --- a/src/parameters/AerosolModalNucleation.jl +++ b/src/parameters/AerosolModalNucleation.jl @@ -10,7 +10,7 @@ DOI:10.1126/science.aaf2649 # Fields $(DocStringExtensions.FIELDS) """ -struct H2S04NucleationParameters{FT} <: ParametersType{FT} +Base.@kwdef struct H2S04NucleationParameters{FT} <: ParametersType{FT} p_b_n::FT p_b_i::FT u_b_n::FT @@ -33,35 +33,38 @@ struct H2S04NucleationParameters{FT} <: ParametersType{FT} a_i::FT end -function H2S04NucleationParameters( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return H2S04NucleationParameters( - FT(data["mam3_nucleation_p_b_n_neutral"]["value"]), - FT(data["mam3_nucleation_p_b_i_ion_induced"]["value"]), - FT(data["mam3_nucleation_u_b_n_neutral"]["value"]), - FT(data["mam3_nucleation_u_b_i_ion_induced"]["value"]), - FT(data["mam3_nucleation_v_b_n_neutral"]["value"]), - FT(data["mam3_nucleation_v_b_i_ion_induced"]["value"]), - FT(data["mam3_nucleation_w_b_n_neutral"]["value"]), - FT(data["mam3_nucleation_w_b_i_ion_induced"]["value"]), - FT(data["mam3_nucleation_p_t_n_neutral"]["value"]), - FT(data["mam3_nucleation_p_t_i_ion_induced"]["value"]), - FT(data["mam3_nucleation_u_t_n_neutral"]["value"]), - FT(data["mam3_nucleation_u_t_i_ion_induced"]["value"]), - FT(data["mam3_nucleation_v_t_n_neutral"]["value"]), - FT(data["mam3_nucleation_v_t_i_ion_induced"]["value"]), - FT(data["mam3_nucleation_w_t_n_neutral"]["value"]), - FT(data["mam3_nucleation_w_t_i_ion_induced"]["value"]), - FT(data["mam3_nucleation_p_A_n_neutral"]["value"]), - FT(data["mam3_nucleation_p_A_i_ion_induced"]["value"]), - FT(data["mam3_nucleation_a_n_neutral"]["value"]), - FT(data["mam3_nucleation_a_i_ion_induced"]["value"]), +H2S04NucleationParameters(::Type{FT}) where {FT <: AbstractFloat} = + H2S04NucleationParameters(CP.create_toml_dict(FT)) + +function H2S04NucleationParameters(td::CP.AbstractTOMLDict) + name_map = (; + :mam3_nucleation_p_b_n_neutral => :p_b_n, + :mam3_nucleation_p_b_i_ion_induced => :p_b_i, + :mam3_nucleation_u_b_n_neutral => :u_b_n, + :mam3_nucleation_u_b_i_ion_induced => :u_b_i, + :mam3_nucleation_v_b_n_neutral => :v_b_n, + :mam3_nucleation_v_b_i_ion_induced => :v_b_i, + :mam3_nucleation_w_b_n_neutral => :w_b_n, + :mam3_nucleation_w_b_i_ion_induced => :w_b_i, + :mam3_nucleation_p_t_n_neutral => :p_t_n, + :mam3_nucleation_p_t_i_ion_induced => :p_t_i, + :mam3_nucleation_u_t_n_neutral => :u_t_n, + :mam3_nucleation_u_t_i_ion_induced => :u_t_i, + :mam3_nucleation_v_t_n_neutral => :v_t_n, + :mam3_nucleation_v_t_i_ion_induced => :v_t_i, + :mam3_nucleation_w_t_n_neutral => :w_t_n, + :mam3_nucleation_w_t_i_ion_induced => :w_t_i, + :mam3_nucleation_p_A_n_neutral => :p_A_n, + :mam3_nucleation_p_A_i_ion_induced => :p_A_i, + :mam3_nucleation_a_n_neutral => :a_n, + :mam3_nucleation_a_i_ion_induced => :a_i, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return H2S04NucleationParameters{FT}(; parameters...) end + """ OrganicNucleationParameters{FT} @@ -71,7 +74,7 @@ DOI: 10.1038/nature17953 # Fields $(DocStringExtensions.FIELDS) """ -struct OrganicNucleationParameters{FT} <: ParametersType{FT} +Base.@kwdef struct OrganicNucleationParameters{FT} <: ParametersType{FT} a_1::FT a_2::FT a_3::FT @@ -85,24 +88,26 @@ struct OrganicNucleationParameters{FT} <: ParametersType{FT} exp_MTOH::FT end -function OrganicNucleationParameters( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return OrganicNucleationParameters( - FT(data["mam3_nucleation_a_1_neutral"]["value"]), - FT(data["mam3_nucleation_a_2_neutral"]["value"]), - FT(data["mam3_nucleation_a_3_ion_induced"]["value"]), - FT(data["mam3_nucleation_a_4_ion_induced"]["value"]), - FT(data["mam3_nucleation_a_5"]["value"]), - FT(data["mam3_nucleation_Y_MTO3_percent"]["value"]), - FT(data["mam3_nucleation_Y_MTOH_percent"]["value"]), - FT(data["mam3_nucleation_k_MTO3_organic_factor"]["value"]), - FT(data["mam3_nucleation_k_MTOH_organic_factor"]["value"]), - FT(data["mam3_nucleation_exp_MTO3_organic_factor"]["value"]), - FT(data["mam3_nucleation_exp_MTOH_organic_factor"]["value"]), +OrganicNucleationParameters(::Type{FT}) where {FT <: AbstractFloat} = + OrganicNucleationParameters(CP.create_toml_dict(FT)) + +function OrganicNucleationParameters(td::CP.AbstractTOMLDict) + name_map = (; + :mam3_nucleation_a_1_neutral => :a_1, + :mam3_nucleation_a_2_neutral => :a_2, + :mam3_nucleation_a_3_ion_induced => :a_3, + :mam3_nucleation_a_4_ion_induced => :a_4, + :mam3_nucleation_a_5 => :a_5, + :mam3_nucleation_Y_MTO3_percent => :Y_MTO3, + :mam3_nucleation_Y_MTOH_percent => :Y_MTOH, + :mam3_nucleation_k_MTO3_organic_factor => :k_MTO3, + :mam3_nucleation_k_MTOH_organic_factor => :k_MTOH, + :mam3_nucleation_exp_MTO3_organic_factor => :exp_MTO3, + :mam3_nucleation_exp_MTOH_organic_factor => :exp_MTOH, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return OrganicNucleationParameters{FT}(; parameters...) end """ @@ -114,22 +119,23 @@ DOI:10.1126/science.1243527 # Fields $(DocStringExtensions.FIELDS) """ -struct MixedNucleationParameters{FT} <: ParametersType{FT} +Base.@kwdef struct MixedNucleationParameters{FT} <: ParametersType{FT} k_H2SO4org::FT k_MTOH::FT exp_MTOH::FT end -function MixedNucleationParameters( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return MixedNucleationParameters( - FT( - data["mam3_nucleation_k_H2SO4_mixed_organic_sulfuric_acid_factor"]["value"], - ), - FT(data["mam3_nucleation_k_MTOH_organic_factor"]["value"]), - FT(data["mam3_nucleation_exp_MTOH_organic_factor"]["value"]), +MixedNucleationParameters(::Type{FT}) where {FT <: AbstractFloat} = + MixedNucleationParameters(CP.create_toml_dict(FT)) + +function MixedNucleationParameters(td::CP.AbstractTOMLDict) + name_map = (; + :mam3_nucleation_k_H2SO4_mixed_organic_sulfuric_acid_factor => + :k_H2SO4org, + :mam3_nucleation_k_MTOH_organic_factor => :k_MTOH, + :mam3_nucleation_exp_MTOH_organic_factor => :exp_MTOH, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return MixedNucleationParameters{FT}(; parameters...) end diff --git a/src/parameters/AerosolSeasalt.jl b/src/parameters/AerosolSeasalt.jl index a4378642c..bf92ae02e 100644 --- a/src/parameters/AerosolSeasalt.jl +++ b/src/parameters/AerosolSeasalt.jl @@ -8,7 +8,7 @@ Parameters for seasalt # Fields $(DocStringExtensions.FIELDS) """ -struct Seasalt{FT} <: AerosolType{FT} +Base.@kwdef struct Seasalt{FT} <: AerosolType{FT} "molar mass [kg/mol]" M::FT "density [kg/m3]" @@ -23,17 +23,19 @@ struct Seasalt{FT} <: AerosolType{FT} κ::FT end -function Seasalt( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Seasalt( - FT(data["seasalt_aerosol_molar_mass"]["value"]), - FT(data["seasalt_aerosol_density"]["value"]), - FT(data["seasalt_aerosol_osmotic_coefficient"]["value"]), - FT(data["seasalt_aerosol_ion_number"]["value"]), - FT(data["seasalt_aerosol_water_soluble_mass_fraction"]["value"]), - FT(data["seasalt_aerosol_kappa"]["value"]), +Seasalt(::Type{FT}) where {FT <: AbstractFloat} = + Seasalt(CP.create_toml_dict(FT)) + +function Seasalt(td::CP.AbstractTOMLDict) + name_map = (; + :seasalt_aerosol_molar_mass => :M, + :seasalt_aerosol_density => :ρ, + :seasalt_aerosol_osmotic_coefficient => :ϕ, + :seasalt_aerosol_ion_number => :ν, + :seasalt_aerosol_water_soluble_mass_fraction => :ϵ, + :seasalt_aerosol_kappa => :κ, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Seasalt{FT}(; parameters...) end diff --git a/src/parameters/AerosolSulfate.jl b/src/parameters/AerosolSulfate.jl index 0d9c1d2c6..3b4375f2f 100644 --- a/src/parameters/AerosolSulfate.jl +++ b/src/parameters/AerosolSulfate.jl @@ -8,7 +8,7 @@ Parameters for sulfate aerosol # Fields $(DocStringExtensions.FIELDS) """ -struct Sulfate{FT} <: AerosolType{FT} +Base.@kwdef struct Sulfate{FT} <: AerosolType{FT} "molar mass [kg/mol]" M::FT "density [kg/m3]" @@ -23,17 +23,19 @@ struct Sulfate{FT} <: AerosolType{FT} κ::FT end -function Sulfate( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Sulfate( - FT(data["sulfate_aerosol_molar_mass"]["value"]), - FT(data["sulfate_aerosol_density"]["value"]), - FT(data["sulfate_aerosol_osmotic_coefficient"]["value"]), - FT(data["sulfate_aerosol_ion_number"]["value"]), - FT(data["sulfate_aerosol_water_soluble_mass_fraction"]["value"]), - FT(data["sulfate_aerosol_kappa"]["value"]), +Sulfate(::Type{FT}) where {FT <: AbstractFloat} = + Sulfate(CP.create_toml_dict(FT)) + +function Sulfate(td::CP.AbstractTOMLDict) + name_map = (; + :sulfate_aerosol_molar_mass => :M, + :sulfate_aerosol_density => :ρ, + :sulfate_aerosol_osmotic_coefficient => :ϕ, + :sulfate_aerosol_ion_number => :ν, + :sulfate_aerosol_water_soluble_mass_fraction => :ϵ, + :sulfate_aerosol_kappa => :κ, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Sulfate{FT}(; parameters...) end diff --git a/src/parameters/Aerosol_H2SO4_Solution.jl b/src/parameters/Aerosol_H2SO4_Solution.jl index a2ea5e4be..13d821653 100644 --- a/src/parameters/Aerosol_H2SO4_Solution.jl +++ b/src/parameters/Aerosol_H2SO4_Solution.jl @@ -9,7 +9,7 @@ from Luo et al 1995. DOI: 10.1029/94GL02988 # Fields $(DocStringExtensions.FIELDS) """ -struct H2SO4SolutionParameters{FT} <: ParametersType{FT} +Base.@kwdef struct H2SO4SolutionParameters{FT} "max temperature for which the parameterization is valid [K]" T_max::FT "min temperature for which the parameterization is valid [K]" @@ -32,21 +32,23 @@ struct H2SO4SolutionParameters{FT} <: ParametersType{FT} c7::FT end -function H2SO4SolutionParameters( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return H2SO4SolutionParameters( - FT(data["p_over_sulphuric_acid_solution_T_max"]["value"]), - FT(data["p_over_sulphuric_acid_solution_T_min"]["value"]), - FT(data["p_over_sulphuric_acid_solution_w_2"]["value"]), - FT(data["p_over_sulphuric_acid_solution_c1"]["value"]), - FT(data["p_over_sulphuric_acid_solution_c2"]["value"]), - FT(data["p_over_sulphuric_acid_solution_c3"]["value"]), - FT(data["p_over_sulphuric_acid_solution_c4"]["value"]), - FT(data["p_over_sulphuric_acid_solution_c5"]["value"]), - FT(data["p_over_sulphuric_acid_solution_c6"]["value"]), - FT(data["p_over_sulphuric_acid_solution_c7"]["value"]), +H2SO4SolutionParameters(::Type{FT}) where {FT <: AbstractFloat} = + H2SO4SolutionParameters(CP.create_toml_dict(FT)) + +function H2SO4SolutionParameters(td::CP.AbstractTOMLDict) + name_map = (; + :p_over_sulphuric_acid_solution_T_max => :T_max, + :p_over_sulphuric_acid_solution_T_min => :T_min, + :p_over_sulphuric_acid_solution_w_2 => :w_2, + :p_over_sulphuric_acid_solution_c1 => :c1, + :p_over_sulphuric_acid_solution_c2 => :c2, + :p_over_sulphuric_acid_solution_c3 => :c3, + :p_over_sulphuric_acid_solution_c4 => :c4, + :p_over_sulphuric_acid_solution_c5 => :c5, + :p_over_sulphuric_acid_solution_c6 => :c6, + :p_over_sulphuric_acid_solution_c7 => :c7, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return H2SO4SolutionParameters{FT}(; parameters...) end diff --git a/src/parameters/AirProperties.jl b/src/parameters/AirProperties.jl index 8e71a1b97..0cad4bc8b 100644 --- a/src/parameters/AirProperties.jl +++ b/src/parameters/AirProperties.jl @@ -8,7 +8,7 @@ Parameters with air properties. # Fields $(DocStringExtensions.FIELDS) """ -struct AirProperties{FT} <: ParametersType{FT} +Base.@kwdef struct AirProperties{FT} <: ParametersType{FT} "thermal conductivity of air [w/m/K]" K_therm::FT "diffusivity of water vapor [m2/s]" @@ -17,14 +17,16 @@ struct AirProperties{FT} <: ParametersType{FT} ν_air::FT end -function AirProperties( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return AirProperties( - FT(data["thermal_conductivity_of_air"]["value"]), - FT(data["diffusivity_of_water_vapor"]["value"]), - FT(data["kinematic_viscosity_of_air"]["value"]), +AirProperties(::Type{FT}) where {FT <: AbstractFloat} = + AirProperties(CP.create_toml_dict(FT)) + +function AirProperties(td::CP.AbstractTOMLDict) + name_map = (; + :thermal_conductivity_of_air => :K_therm, + :diffusivity_of_water_vapor => :D_vapor, + :kinematic_viscosity_of_air => :ν_air, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return AirProperties{FT}(; parameters...) end diff --git a/src/parameters/IceNucleation.jl b/src/parameters/IceNucleation.jl index d0adb59ed..9f313738f 100644 --- a/src/parameters/IceNucleation.jl +++ b/src/parameters/IceNucleation.jl @@ -9,22 +9,21 @@ DOI: 10.5194/acp-6-3007-2006 # Fields $(DocStringExtensions.FIELDS) """ -struct Mohler2006{FT} <: ParametersType{FT} +Base.@kwdef struct Mohler2006{FT} <: ParametersType{FT} "max allowed supersaturation [-]" Sᵢ_max::FT "threshold temperature [K]" T_thr::FT end -function Mohler2006( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Mohler2006( - FT(data["Mohler2006_maximum_allowed_Si"]["value"]), - FT(data["Mohler2006_threshold_T"]["value"]), +function Mohler2006(td::CP.AbstractTOMLDict) + name_map = (; + :Mohler2006_maximum_allowed_Si => :Sᵢ_max, + :Mohler2006_threshold_T => :T_thr, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Mohler2006{FT}(; parameters...) end """ @@ -36,7 +35,7 @@ DOI: 10.1038/35020537 # Fields $(DocStringExtensions.FIELDS) """ -struct Koop2000{FT} <: ParametersType{FT} +Base.@kwdef struct Koop2000{FT} <: ParametersType{FT} "min Δaw [-]" Δa_w_min::FT "max Δaw [-]" @@ -51,19 +50,18 @@ struct Koop2000{FT} <: ParametersType{FT} c₄::FT end -function Koop2000( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Koop2000( - FT(data["Koop2000_min_delta_aw"]["value"]), - FT(data["Koop2000_max_delta_aw"]["value"]), - FT(data["Koop2000_J_hom_coeff1"]["value"]), - FT(data["Koop2000_J_hom_coeff2"]["value"]), - FT(data["Koop2000_J_hom_coeff3"]["value"]), - FT(data["Koop2000_J_hom_coeff4"]["value"]), +function Koop2000(td::CP.AbstractTOMLDict) + name_map = (; + :Koop2000_min_delta_aw => :Δa_w_min, + :Koop2000_max_delta_aw => :Δa_w_max, + :Koop2000_J_hom_coeff1 => :c₁, + :Koop2000_J_hom_coeff2 => :c₂, + :Koop2000_J_hom_coeff3 => :c₃, + :Koop2000_J_hom_coeff4 => :c₄, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Koop2000{FT}(; parameters...) end """ @@ -83,10 +81,9 @@ function IceNucleationParameters( ::Type{FT}, toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), ) where {FT} - deposition = Mohler2006(FT, toml_dict) - homogeneous = Koop2000(FT, toml_dict) - return IceNucleationParameters{FT, typeof(deposition), typeof(homogeneous)}( - deposition, - homogeneous, - ) + deposition = Mohler2006(toml_dict) + homogeneous = Koop2000(toml_dict) + DEP = typeof(deposition) + HOM = typeof(homogeneous) + return IceNucleationParameters{FT, DEP, HOM}(deposition, homogeneous) end diff --git a/src/parameters/Microphysics0M.jl b/src/parameters/Microphysics0M.jl index 6d1bc515d..e704a095b 100644 --- a/src/parameters/Microphysics0M.jl +++ b/src/parameters/Microphysics0M.jl @@ -8,7 +8,7 @@ Parameters for zero-moment bulk microphysics scheme # Fields $(DocStringExtensions.FIELDS) """ -struct Parameters0M{FT} <: ParametersType{FT} +Base.@kwdef struct Parameters0M{FT} <: ParametersType{FT} "precipitation timescale [s]" τ_precip::FT "specific humidity precipitation threshold [-]" @@ -17,14 +17,16 @@ struct Parameters0M{FT} <: ParametersType{FT} S_0::FT end -function Parameters0M( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Parameters0M( - FT(data["precipitation_timescale"]["value"]), - FT(data["specific_humidity_precipitation_threshold"]["value"]), - FT(data["supersaturation_precipitation_threshold"]["value"]), +Parameters0M(::Type{FT}) where {FT <: AbstractFloat} = + Parameters0M(CP.create_toml_dict(FT)) + +function Parameters0M(td::CP.AbstractTOMLDict) + name_map = (; + :precipitation_timescale => :τ_precip, + :specific_humidity_precipitation_threshold => :qc_0, + :supersaturation_precipitation_threshold => :S_0, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Parameters0M{FT}(; parameters...) end diff --git a/src/parameters/Microphysics1M.jl b/src/parameters/Microphysics1M.jl index fa13a7dff..f0cd17279 100644 --- a/src/parameters/Microphysics1M.jl +++ b/src/parameters/Microphysics1M.jl @@ -8,7 +8,7 @@ A struct with snow size distribution parameters # Fields $(DocStringExtensions.FIELDS) """ -struct ParticlePDFSnow{FT} <: ParametersType{FT} +Base.@kwdef struct ParticlePDFSnow{FT} <: ParametersType{FT} "snow size distribution coefficient [1/m4]" μ::FT "snow size distribution coefficient [-]" @@ -38,7 +38,7 @@ m(r) = m0 χm (r/r0)^(me + Δm) # Fields $(DocStringExtensions.FIELDS) """ -struct ParticleMass{FT} <: ParametersType{FT} +Base.@kwdef struct ParticleMass{FT} <: ParametersType{FT} "particle length scale [m]" r0::FT "mass size relation coefficient [kg]" @@ -62,7 +62,7 @@ a(r) = a0 χa (r/r0)^(ae + Δa) # Fields $(DocStringExtensions.FIELDS) """ -struct ParticleArea{FT} <: ParametersType{FT} +Base.@kwdef struct ParticleArea{FT} <: ParametersType{FT} "cross section size relation coefficient [m2]" a0::FT "cross section size relation coefficient [-]" @@ -118,12 +118,15 @@ struct CloudLiquid{FT} <: CloudCondensateType{FT} τ_relax::FT end -function CloudLiquid( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return CloudLiquid(FT(data["condensation_evaporation_timescale"]["value"])) +CloudLiquid(::Type{FT}) where {FT <: AbstractFloat} = + CloudLiquid(CP.create_toml_dict(FT)) + +function CloudLiquid(toml_dict::CP.AbstractTOMLDict) + name_map = (; :condensation_evaporation_timescale => :τ_relax) + (; τ_relax) = + CP.get_parameter_values(toml_dict, name_map, "CloudMicrophysics") + FT = CP.float_type(toml_dict) + return CloudLiquid{FT}(τ_relax) end """ @@ -147,31 +150,39 @@ struct CloudIce{FT, PD, MS} <: CloudCondensateType{FT} τ_relax::FT end -function CloudIce( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - - n0 = FT(data["cloud_ice_size_distribution_coefficient_n0"]["value"]) - pdf = ParticlePDFIceRain(n0) - - ρi = FT(data["density_ice_water"]["value"]) - r0 = FT(data["cloud_ice_crystals_length_scale"]["value"]) - - me = FT(data["cloud_ice_mass_size_relation_coefficient_me"]["value"]) - m0 = FT(4 / 3) * π * ρi * r0^me - Δm = FT(data["cloud_ice_mass_size_relation_coefficient_delm"]["value"]) - χm = FT(data["cloud_ice_mass_size_relation_coefficient_chim"]["value"]) - mass = ParticleMass(r0, m0, me, Δm, χm) +CloudIce(::Type{FT}) where {FT <: AbstractFloat} = + CloudIce(CP.create_toml_dict(FT)) + +function CloudIce(toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT)) + name_map = (; + :density_ice_water => :ρi, + :cloud_ice_crystals_length_scale => :r0, + :cloud_ice_size_distribution_coefficient_n0 => :n0, + :cloud_ice_mass_size_relation_coefficient_me => :me, + :ice_snow_threshold_radius => :r_ice_snow, + :sublimation_deposition_timescale => :τ_relax, + ) + p = CP.get_parameter_values(toml_dict, name_map, "CloudMicrophysics") + mass = ParticleMass(CloudIce, toml_dict) + pdf = ParticlePDFIceRain(p.n0) + FT = CP.float_type(toml_dict) + P = typeof(pdf) + M = typeof(mass) + return CloudIce{FT, P, M}(pdf, mass, p.r0, p.r_ice_snow, p.τ_relax) +end - return CloudIce{FT, typeof(pdf), typeof(mass)}( - pdf, - mass, - r0, - FT(data["ice_snow_threshold_radius"]["value"]), - FT(data["sublimation_deposition_timescale"]["value"]), +function ParticleMass(::Type{CloudIce}, td::CP.AbstractTOMLDict) + name_map = (; + :density_ice_water => :ρi, + :cloud_ice_crystals_length_scale => :r0, + :cloud_ice_mass_size_relation_coefficient_me => :me, + :cloud_ice_mass_size_relation_coefficient_delm => :Δm, + :cloud_ice_mass_size_relation_coefficient_chim => :χm, ) + p = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + m0 = 4 / 3 * π * p.ρi * p.r0^p.me + FT = CP.float_type(td) + return ParticleMass{FT}(; p.r0, m0, p.me, p.Δm, p.χm) end """ @@ -197,56 +208,64 @@ struct Rain{FT, PD, MS, AR, VT, AC} <: PrecipitationType{FT} r0::FT end -function Rain( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - - ρ = FT(data["density_liquid_water"]["value"]) - r0 = FT(data["rain_drop_length_scale"]["value"]) - - n0 = FT(data["rain_drop_size_distribution_coefficient_n0"]["value"]) - pdf = ParticlePDFIceRain(n0) - - me = FT(data["rain_mass_size_relation_coefficient_me"]["value"]) - m0 = FT(4 / 3) * π * ρ * r0^me - Δm = FT(data["rain_mass_size_relation_coefficient_delm"]["value"]) - χm = FT(data["rain_mass_size_relation_coefficient_chim"]["value"]) - mass = ParticleMass(r0, m0, me, Δm, χm) - - ae = FT(data["rain_cross_section_size_relation_coefficient_ae"]["value"]) - Δa = FT(data["rain_cross_section_size_relation_coefficient_dela"]["value"]) # typo in .toml file - χa = FT(data["rain_cross_section_size_relation_coefficient_chia"]["value"]) - a0 = FT(π) * r0^ae - area = ParticleArea(a0, ae, Δa, χa) - - a = FT(data["rain_ventillation_coefficient_a"]["value"]) - b = FT(data["rain_ventillation_coefficient_b"]["value"]) - vent = Ventilation(a, b) - - τ = FT(data["rain_autoconversion_timescale"]["value"]) - q_threshold = FT( - data["cloud_liquid_water_specific_humidity_autoconversion_threshold"]["value"], +Rain(::Type{FT}) where {FT <: AbstractFloat} = Rain(CP.create_toml_dict(FT)) + +function Rain(toml_dict::CP.AbstractTOMLDict) + name_map = (; + :density_liquid_water => :ρ, + :rain_drop_length_scale => :r0, + :rain_drop_size_distribution_coefficient_n0 => :n0, + :rain_mass_size_relation_coefficient_me => :me, + :rain_cross_section_size_relation_coefficient_ae => :ae, + :rain_autoconversion_timescale => :τ, + :cloud_liquid_water_specific_humidity_autoconversion_threshold => + :q_threshold, + :threshold_smooth_transition_steepness => :k, + :rain_ventillation_coefficient_a => :a, + :rain_ventillation_coefficient_b => :b, ) - k = FT(data["threshold_smooth_transition_steepness"]["value"]) - acnv1M = Acnv1M(τ, q_threshold, k) + p = CP.get_parameter_values(toml_dict, name_map, "CloudMicrophysics") + + mass = ParticleMass(Rain, toml_dict) + area = ParticleArea(Rain, toml_dict) + pdf = ParticlePDFIceRain(p.n0) + vent = Ventilation(p.a, p.b) + acnv1M = Acnv1M(p.τ, p.q_threshold, p.k) + + FT = CP.float_type(toml_dict) + P = typeof(pdf) + M = typeof(mass) + A = typeof(area) + V = typeof(vent) + AC = typeof(acnv1M) + return Rain{FT, P, M, A, V, AC}(pdf, mass, area, vent, acnv1M, p.r0) +end - return Rain{ - FT, - typeof(pdf), - typeof(mass), - typeof(area), - typeof(vent), - typeof(acnv1M), - }( - pdf, - mass, - area, - vent, - acnv1M, - r0, +function ParticleMass(::Type{Rain}, td::CP.AbstractTOMLDict) + name_map = (; + :density_liquid_water => :ρ, + :rain_drop_length_scale => :r0, + :rain_mass_size_relation_coefficient_me => :me, + :rain_mass_size_relation_coefficient_delm => :Δm, + :rain_mass_size_relation_coefficient_chim => :χm, + ) + p = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + m0 = 4 / 3 * π * p.ρ * p.r0^p.me + FT = CP.float_type(td) + return ParticleMass{FT}(; p.r0, m0, p.me, p.Δm, p.χm) +end + +function ParticleArea(::Type{Rain}, td::CP.AbstractTOMLDict) + name_map = (; + :rain_drop_length_scale => :r0, + :rain_cross_section_size_relation_coefficient_ae => :ae, + :rain_cross_section_size_relation_coefficient_dela => :Δa, + :rain_cross_section_size_relation_coefficient_chia => :χa, ) + p = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + a0 = π * p.r0^p.ae + FT = CP.float_type(td) + return ParticleArea{FT}(; a0, p.ae, p.Δa, p.χa) end """ @@ -276,42 +295,30 @@ struct Snow{FT, PD, MS, AR, VT, AC} <: PrecipitationType{FT} ρᵢ::FT end -function Snow( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - - r0 = FT(data["snow_flake_length_scale"]["value"]) - ρi = FT(data["density_ice_water"]["value"]) - - μ = FT(data["snow_flake_size_distribution_coefficient_mu"]["value"]) - ν = FT(data["snow_flake_size_distribution_coefficient_nu"]["value"]) - pdf = ParticlePDFSnow(μ, ν) - - me = FT(data["snow_mass_size_relation_coefficient_me"]["value"]) - m0 = FT(1e-1) * r0^me - Δm = FT(data["snow_mass_size_relation_coefficient_delm"]["value"]) - χm = FT(data["snow_mass_size_relation_coefficient_chim"]["value"]) - mass = ParticleMass(r0, m0, me, Δm, χm) - - ae = FT(data["snow_cross_section_size_relation_coefficient"]["value"]) - Δa = FT(data["snow_cross_section_size_relation_coefficient_dela"]["value"]) # typo in .toml file - χa = FT(data["snow_cross_section_size_relation_coefficient_chia"]["value"]) - a0 = FT(0.3) * π * r0^ae - area = ParticleArea(a0, ae, Δa, χa) - - a = FT(data["snow_ventillation_coefficient_a"]["value"]) - b = FT(data["snow_ventillation_coefficient_b"]["value"]) - vent = Ventilation(a, b) - - τ = FT(data["snow_autoconversion_timescale"]["value"]) - q_threshold = FT( - data["cloud_ice_specific_humidity_autoconversion_threshold"]["value"], +Snow(::Type{FT}) where {FT <: AbstractFloat} = Snow(CP.create_toml_dict(FT)) + +function Snow(toml_dict::CP.AbstractTOMLDict) + name_map = (; + :cloud_ice_crystals_length_scale => :r0, + :density_ice_water => :ρi, + :snow_autoconversion_timescale => :τ, + :cloud_ice_specific_humidity_autoconversion_threshold => + :q_threshold, + :threshold_smooth_transition_steepness => :k, + :temperature_water_freeze => :T_freeze, + :snow_flake_size_distribution_coefficient_mu => :μ, + :snow_flake_size_distribution_coefficient_nu => :ν, + :snow_ventillation_coefficient_a => :a, + :snow_ventillation_coefficient_b => :b, ) - k = FT(data["threshold_smooth_transition_steepness"]["value"]) - acnv1M = Acnv1M(τ, q_threshold, k) - + p = CP.get_parameter_values(toml_dict, name_map, "CloudMicrophysics") + + mass = ParticleMass(Snow, toml_dict) + area = ParticleArea(Snow, toml_dict) + pdf = ParticlePDFSnow(p.μ, p.ν) + vent = Ventilation(p.a, p.b) + acnv1M = Acnv1M(p.τ, p.q_threshold, p.k) + FT = CP.float_type(toml_dict) return Snow{ FT, typeof(pdf), @@ -325,10 +332,37 @@ function Snow( area, vent, acnv1M, - r0, - FT(data["temperature_water_freeze"]["value"]), - ρi, + p.r0, + p.T_freeze, + p.ρi, + ) +end + +function ParticleMass(::Type{Snow}, td::CP.AbstractTOMLDict) + name_map = (; + :density_liquid_water => :ρ, + :snow_flake_length_scale => :r0, + :snow_mass_size_relation_coefficient_me => :me, + :snow_mass_size_relation_coefficient_delm => :Δm, + :snow_mass_size_relation_coefficient_chim => :χm, ) + p = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + m0 = 1e-1 * p.r0^p.me + FT = CP.float_type(td) + return ParticleMass{FT}(; p.r0, m0, p.me, p.Δm, p.χm) +end + +function ParticleArea(::Type{Snow}, toml_dict::CP.AbstractTOMLDict) + name_map = (; + :snow_flake_length_scale => :r0, + :snow_cross_section_size_relation_coefficient => :ae, + :snow_cross_section_size_relation_coefficient_dela => :Δa, + :snow_cross_section_size_relation_coefficient_chia => :χa, + ) + p = CP.get_parameter_values(toml_dict, name_map, "CloudMicrophysics") + a0 = 0.3 * π * p.r0^p.ae + FT = CP.float_type(toml_dict) + return ParticleArea{FT}(; a0, p.ae, p.Δa, p.χa) end """ @@ -339,7 +373,7 @@ Collision efficiency parameters for the 1-moment scheme # Fields $(DocStringExtensions.FIELDS) """ -struct CollisionEff{FT} <: ParametersType{FT} +Base.@kwdef struct CollisionEff{FT} <: ParametersType{FT} "cloud liquid-rain collision efficiency [-]" e_liq_rai::FT "cloud liquid-snow collision efficiency [-]" @@ -352,16 +386,18 @@ struct CollisionEff{FT} <: ParametersType{FT} e_rai_sno::FT end -function CollisionEff( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return CollisionEff( - FT(data["cloud_liquid_rain_collision_efficiency"]["value"]), - FT(data["cloud_liquid_snow_collision_efficiency"]["value"]), - FT(data["cloud_ice_rain_collision_efficiency"]["value"]), - FT(data["cloud_ice_snow_collision_efficiency"]["value"]), - FT(data["rain_snow_collision_efficiency"]["value"]), +CollisionEff(::Type{FT}) where {FT <: AbstractFloat} = + CollisionEff(CP.create_toml_dict(FT)) + +function CollisionEff(td::CP.AbstractTOMLDict) + name_map = (; + :cloud_liquid_rain_collision_efficiency => :e_liq_rai, + :cloud_liquid_snow_collision_efficiency => :e_liq_sno, + :cloud_ice_rain_collision_efficiency => :e_ice_rai, + :cloud_ice_snow_collision_efficiency => :e_ice_sno, + :rain_snow_collision_efficiency => :e_rai_sno, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return CollisionEff{FT}(; parameters...) end diff --git a/src/parameters/Microphysics2M.jl b/src/parameters/Microphysics2M.jl index 5cde24fd4..a74d45b8f 100644 --- a/src/parameters/Microphysics2M.jl +++ b/src/parameters/Microphysics2M.jl @@ -8,7 +8,7 @@ Khairoutdinov and Kogan (2000) autoconversion parameters # Fields $(DocStringExtensions.FIELDS) """ -struct AcnvKK2000{FT} <: ParametersType{FT} +Base.@kwdef struct AcnvKK2000{FT} <: ParametersType{FT} "Autoconversion coefficient A" A::FT "Autoconversion coefficient a" @@ -19,6 +19,18 @@ struct AcnvKK2000{FT} <: ParametersType{FT} c::FT end +function AcnvKK2000(td::CP.AbstractTOMLDict) + name_map = (; + :KK2000_auctoconversion_coeff_A => :A, + :KK2000_auctoconversion_coeff_a => :a, + :KK2000_auctoconversion_coeff_b => :b, + :KK2000_auctoconversion_coeff_c => :c, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return AcnvKK2000{FT}(; parameters...) +end + """ AccrKK2000 @@ -27,7 +39,7 @@ Khairoutdinov and Kogan (2000) accretion parameters # Fields $(DocStringExtensions.FIELDS) """ -struct AccrKK2000{FT} <: ParametersType{FT} +Base.@kwdef struct AccrKK2000{FT} <: ParametersType{FT} "Accretion coefficient A" A::FT "Accretion coefficient a" @@ -36,6 +48,17 @@ struct AccrKK2000{FT} <: ParametersType{FT} b::FT end +function AccrKK2000(td::CP.AbstractTOMLDict) + name_map = (; + :KK2000_accretion_coeff_A => :A, + :KK2000_accretion_coeff_a => :a, + :KK2000_accretion_coeff_b => :b, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return AccrKK2000{FT}(; parameters...) +end + """ KK2000 @@ -58,18 +81,8 @@ function KK2000( ::Type{FT}, toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), ) where {FT} - (; data) = toml_dict - acnv = AcnvKK2000( - FT(data["KK2000_auctoconversion_coeff_A"]["value"]), - FT(data["KK2000_auctoconversion_coeff_a"]["value"]), - FT(data["KK2000_auctoconversion_coeff_b"]["value"]), - FT(data["KK2000_auctoconversion_coeff_c"]["value"]), - ) - accr = AccrKK2000( - FT(data["KK2000_accretion_coeff_A"]["value"]), - FT(data["KK2000_accretion_coeff_a"]["value"]), - FT(data["KK2000_accretion_coeff_b"]["value"]), - ) + acnv = AcnvKK2000(toml_dict) + accr = AccrKK2000(toml_dict) return KK2000{FT, typeof(acnv), typeof(accr)}(acnv, accr) end @@ -81,7 +94,7 @@ Beheng (1994) autoconversion parameters # Fields $(DocStringExtensions.FIELDS) """ -struct AcnvB1994{FT} <: ParametersType{FT} +Base.@kwdef struct AcnvB1994{FT} <: ParametersType{FT} "Autoconversion coeff C" C::FT "Autoconversion coeff a" @@ -100,6 +113,22 @@ struct AcnvB1994{FT} <: ParametersType{FT} k::FT end +function AcnvB1994(td::CP.AbstractTOMLDict) + name_map = (; + :B1994_auctoconversion_coeff_C => :C, + :B1994_auctoconversion_coeff_a => :a, + :B1994_auctoconversion_coeff_b => :b, + :B1994_auctoconversion_coeff_c => :c, + :B1994_auctoconversion_coeff_N_0 => :N_0, + :B1994_auctoconversion_coeff_d_low => :d_low, + :B1994_auctoconversion_coeff_d_high => :d_high, + :threshold_smooth_transition_steepness => :k, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return AcnvB1994{FT}(; parameters...) +end + """ AccrB1994 @@ -113,6 +142,16 @@ struct AccrB1994{FT} <: ParametersType{FT} A::FT end +function AccrB1994(toml_dict::CP.AbstractTOMLDict) + (; B1994_accretion_coeff_A) = CP.get_parameter_values( + toml_dict, + "B1994_accretion_coeff_A", + "CloudMicrophysics", + ) + FT = CP.float_type(toml_dict) + return AccrB1994{FT}(B1994_accretion_coeff_A) +end + """ B1994 @@ -129,24 +168,12 @@ struct B1994{FT, AV, AR} <: Precipitation2MType{FT} accr::AR end -function B1994( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - - acnv = AcnvB1994( - FT(data["B1994_auctoconversion_coeff_C"]["value"]), - FT(data["B1994_auctoconversion_coeff_a"]["value"]), - FT(data["B1994_auctoconversion_coeff_b"]["value"]), - FT(data["B1994_auctoconversion_coeff_c"]["value"]), - FT(data["B1994_auctoconversion_coeff_N_0"]["value"]), - FT(data["B1994_auctoconversion_coeff_d_low"]["value"]), # typo aucto => auto - FT(data["B1994_auctoconversion_coeff_d_high"]["value"]), # type aucto => auto - FT(data["threshold_smooth_transition_steepness"]["value"]), - ) - accr = AccrB1994(FT(data["B1994_accretion_coeff_A"]["value"])) +B1994(::Type{FT}) where {FT <: AbstractFloat} = B1994(CP.create_toml_dict(FT)) +function B1994(toml_dict::CP.AbstractTOMLDict) + acnv = AcnvB1994(toml_dict) + accr = AccrB1994(toml_dict) + FT = CP.float_type(toml_dict) return B1994{FT, typeof(acnv), typeof(accr)}(acnv, accr) end @@ -158,7 +185,7 @@ Tripoli and Cotton (1980) autoconversion parameters # Fields $(DocStringExtensions.FIELDS) """ -struct AcnvTC1980{FT} <: ParametersType{FT} +Base.@kwdef struct AcnvTC1980{FT} <: ParametersType{FT} "Autoconversion coefficient a" a::FT "Autoconversion coefficient b" @@ -175,6 +202,23 @@ struct AcnvTC1980{FT} <: ParametersType{FT} k::FT end +function AcnvTC1980(td::CP.AbstractTOMLDict) + name_map = (; + :TC1980_autoconversion_coeff_a => :a, + :TC1980_autoconversion_coeff_b => :b, + :TC1980_autoconversion_coeff_D => :D, + :TC1980_autoconversion_coeff_r_0 => :r_0, + :TC1980_autoconversion_coeff_me_liq => :me_liq, + :threshold_smooth_transition_steepness => :k, + :density_liquid_water => :m0_liq_coeff, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + m0_liq_coeff = 4 / 3 * π * parameters.m0_liq_coeff + + FT = CP.float_type(td) + return AcnvTC1980{FT}(; parameters..., m0_liq_coeff) +end + """ AccrTC1980 @@ -188,6 +232,16 @@ struct AccrTC1980{FT} <: ParametersType{FT} A::FT end +function AccrTC1980(toml_dict::CP.AbstractTOMLDict) + (; TC1980_accretion_coeff_A) = CP.get_parameter_values( + toml_dict, + "TC1980_accretion_coeff_A", + "CloudMicrophysics", + ) + FT = CP.float_type(toml_dict) + return AccrTC1980{FT}(TC1980_accretion_coeff_A) +end + """ TC1980 @@ -206,23 +260,12 @@ struct TC1980{FT, AV, AR} <: Precipitation2MType{FT} accr::AR end -function TC1980( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - ρ_cloud_liq = FT(data["density_liquid_water"]["value"]) - acnv = AcnvTC1980( - FT(data["TC1980_autoconversion_coeff_a"]["value"]), - FT(data["TC1980_autoconversion_coeff_b"]["value"]), - FT(data["TC1980_autoconversion_coeff_D"]["value"]), - FT(data["TC1980_autoconversion_coeff_r_0"]["value"]), - FT(data["TC1980_autoconversion_coeff_me_liq"]["value"]), - FT(4 / 3) * π * ρ_cloud_liq, - FT(data["threshold_smooth_transition_steepness"]["value"]), - ) - accr = AccrTC1980(FT(data["TC1980_accretion_coeff_A"]["value"])) +TC1980(::Type{FT}) where {FT <: AbstractFloat} = TC1980(CP.create_toml_dict(FT)) +function TC1980(toml_dict::CP.AbstractTOMLDict) + acnv = AcnvTC1980(toml_dict) + accr = AccrTC1980(toml_dict) + FT = CP.float_type(toml_dict) return TC1980{FT, typeof(acnv), typeof(accr)}(acnv, accr) end @@ -237,7 +280,7 @@ DOI: 10.1175/1520-0469(2004)061<1539:POTAPI>2.0.CO;2 # Fields $(DocStringExtensions.FIELDS) """ -struct LD2004{FT} <: Precipitation2MType{FT} +Base.@kwdef struct LD2004{FT} <: Precipitation2MType{FT} "Autoconversion coefficient R_6C_0" R_6C_0::FT "Autoconversion coefficient E_0" @@ -248,17 +291,18 @@ struct LD2004{FT} <: Precipitation2MType{FT} k::FT end -function LD2004( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return LD2004( - FT(data["LD2004_R_6C_coeff"]["value"]), - FT(data["LD2004_E_0_coeff"]["value"]), - FT(data["density_liquid_water"]["value"]), - FT(data["threshold_smooth_transition_steepness"]["value"]), +LD2004(::Type{FT}) where {FT <: AbstractFloat} = LD2004(CP.create_toml_dict(FT)) + +function LD2004(td::CP.AbstractTOMLDict) + name_map = (; + :LD2004_R_6C_coeff => :R_6C_0, + :LD2004_E_0_coeff => :E_0, + :density_liquid_water => :ρ_w, + :threshold_smooth_transition_steepness => :k, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return LD2004{FT}(; parameters...) end """ @@ -270,22 +314,24 @@ The type for 2-moment precipitation formation based on the # Fields $(DocStringExtensions.FIELDS) """ -struct VarTimescaleAcnv{FT} <: Precipitation2MType{FT} +Base.@kwdef struct VarTimescaleAcnv{FT} <: Precipitation2MType{FT} "Timescale [s]" τ::FT "Powerlaw coefficient [-]" α::FT end -function VarTimescaleAcnv( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return VarTimescaleAcnv( - FT(data["rain_autoconversion_timescale"]["value"]), - FT(data["Variable_time_scale_autoconversion_coeff_alpha"]["value"]), +VarTimescaleAcnv(::Type{FT}) where {FT <: AbstractFloat} = + VarTimescaleAcnv(CP.create_toml_dict(FT)) + +function VarTimescaleAcnv(td::CP.AbstractTOMLDict) + name_map = (; + :rain_autoconversion_timescale => :τ, + :Variable_time_scale_autoconversion_coeff_alpha => :α, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return VarTimescaleAcnv{FT}(; parameters...) end """ @@ -296,7 +342,7 @@ Rain size distribution parameters from SB2006 # Fields $(DocStringExtensions.FIELDS) """ -struct ParticlePDF_SB2006{FT} <: ParametersType{FT} +Base.@kwdef struct ParticlePDF_SB2006{FT} <: ParametersType{FT} "Raindrop minimal mass" xr_min::FT "Raindrop maximum mass" @@ -315,6 +361,22 @@ struct ParticlePDF_SB2006{FT} <: ParametersType{FT} ρ0::FT end +function ParticlePDF_SB2006(td::CP.AbstractTOMLDict) + name_map = (; + :SB2006_raindrops_min_mass => :xr_min, + :SB2006_raindrops_max_mass => :xr_max, + :SB2006_raindrops_size_distribution_coeff_N0_min => :N0_min, + :SB2006_raindrops_size_distribution_coeff_N0_max => :N0_max, + :SB2006_raindrops_size_distribution_coeff_lambda_min => :λ_min, + :SB2006_raindrops_size_distribution_coeff_lambda_max => :λ_max, + :density_liquid_water => :ρw, + :SB2006_reference_air_density => :ρ0, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return ParticlePDF_SB2006{FT}(; parameters...) +end + """ AcnvSB2006 @@ -323,7 +385,7 @@ Autoconversion parameters from SB2006 # Fields $(DocStringExtensions.FIELDS) """ -struct AcnvSB2006{FT} <: ParametersType{FT} +Base.@kwdef struct AcnvSB2006{FT} <: ParametersType{FT} "Collection kernel coefficient" kcc::FT "Cloud gamma distribution coefficient" @@ -340,6 +402,22 @@ struct AcnvSB2006{FT} <: ParametersType{FT} b::FT end +function AcnvSB2006(td::CP.AbstractTOMLDict) + name_map = (; + :SB2006_collection_kernel_coeff_kcc => :kcc, + :SB2006_cloud_gamma_distribution_parameter => :νc, + :SB2006_raindrops_min_mass => :x_star, + :SB2006_reference_air_density => :ρ0, + :SB2006_autoconversion_correcting_function_coeff_A => :A, + :SB2006_autoconversion_correcting_function_coeff_a => :a, + :SB2006_autoconversion_correcting_function_coeff_b => :b, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return AcnvSB2006{FT}(; parameters...) +end + + """ AccrSB2006 @@ -348,7 +426,7 @@ Accretion parameters from SB2006 # Fields $(DocStringExtensions.FIELDS) """ -struct AccrSB2006{FT} <: ParametersType{FT} +Base.@kwdef struct AccrSB2006{FT} <: ParametersType{FT} "Collection kernel coefficient Kcr" kcr::FT "Accretion correcting function coefficient τ_0" @@ -359,6 +437,18 @@ struct AccrSB2006{FT} <: ParametersType{FT} c::FT end +function AccrSB2006(td::CP.AbstractTOMLDict) + name_map = (; + :SB2006_collection_kernel_coeff_kcr => :kcr, + :SB2006_accretion_correcting_function_coeff_tau0 => :τ0, + :SB2006_reference_air_density => :ρ0, + :SB2006_accretion_correcting_function_coeff_c => :c, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return AccrSB2006{FT}(; parameters...) +end + """ SelfColSB2006 @@ -367,7 +457,7 @@ Rain selfcollection parameters from SB2006 # Fields $(DocStringExtensions.FIELDS) """ -struct SelfColSB2006{FT} <: ParametersType{FT} +Base.@kwdef struct SelfColSB2006{FT} <: ParametersType{FT} "Collection kernel coefficient krr" krr::FT "Collection kernel coefficient kappa rr" @@ -376,6 +466,17 @@ struct SelfColSB2006{FT} <: ParametersType{FT} d::FT end +function SelfColSB2006(td::CP.AbstractTOMLDict) + name_map = (; + :SB2006_collection_kernel_coeff_krr => :krr, + :SB2006_collection_kernel_coeff_kapparr => :κrr, + Symbol("SB2006_raindrops_self-collection_coeff_d") => :d, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return SelfColSB2006{FT}(; parameters...) +end + """ BreakupSB2006 @@ -384,7 +485,7 @@ Rain breakup parameters from SB2006 # Fields $(DocStringExtensions.FIELDS) """ -struct BreakupSB2006{FT} <: ParametersType{FT} +Base.@kwdef struct BreakupSB2006{FT} <: ParametersType{FT} "Raindrop equilibrium mean diamater" Deq::FT "Raindrop breakup mean diamater threshold" @@ -395,6 +496,18 @@ struct BreakupSB2006{FT} <: ParametersType{FT} κbr::FT end +function BreakupSB2006(td::CP.AbstractTOMLDict) + name_map = (; + :SB2006_raindrops_equlibrium_mean_diameter => :Deq, + :SB2006_raindrops_breakup_mean_diameter_threshold => :Dr_th, + :SB2006_raindrops_breakup_coeff_kbr => :kbr, + :SB2006_raindrops_breakup_coeff_kappabr => :κbr, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return BreakupSB2006{FT}(; parameters...) +end + """ EvaporationSB2006 @@ -403,7 +516,7 @@ Rain evaporation parameters from SB2006 # Fields $(DocStringExtensions.FIELDS) """ -struct EvaporationSB2006{FT} <: ParametersType{FT} +Base.@kwdef struct EvaporationSB2006{FT} <: ParametersType{FT} "Ventillation coefficient a" av::FT "Ventillation coefficient b" @@ -416,6 +529,19 @@ struct EvaporationSB2006{FT} <: ParametersType{FT} ρ0::FT end +function EvaporationSB2006(td::CP.AbstractTOMLDict) + name_map = (; + :SB2006_ventilation_factor_coeff_av => :av, + :SB2006_ventilation_factor_coeff_bv => :bv, + :SB2006_rain_evaportation_coeff_alpha => :α, + :SB2006_rain_evaportation_coeff_beta => :β, + :SB2006_reference_air_density => :ρ0, + ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return EvaporationSB2006{FT}(; parameters...) +end + """ SB2006 @@ -442,73 +568,21 @@ struct SB2006{FT, PD, AV, AR, SC, BR, EV} <: Precipitation2MType{FT} evap::EV end -function SB2006( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - - pdf = ParticlePDF_SB2006( - FT(data["SB2006_raindrops_min_mass"]["value"]), - FT(data["SB2006_raindrops_max_mass"]["value"]), - FT(data["SB2006_raindrops_size_distribution_coeff_N0_min"]["value"]), - FT(data["SB2006_raindrops_size_distribution_coeff_N0_max"]["value"]), - FT( - data["SB2006_raindrops_size_distribution_coeff_lambda_min"]["value"], - ), - FT( - data["SB2006_raindrops_size_distribution_coeff_lambda_max"]["value"], - ), - FT(data["density_liquid_water"]["value"]), - FT(data["SB2006_reference_air_density"]["value"]), - ) - acnv = AcnvSB2006( - FT(data["SB2006_collection_kernel_coeff_kcc"]["value"]), - FT(data["SB2006_cloud_gamma_distribution_parameter"]["value"]), - FT(data["SB2006_raindrops_min_mass"]["value"]), - FT(data["SB2006_reference_air_density"]["value"]), - FT(data["SB2006_autoconversion_correcting_function_coeff_A"]["value"]), - FT(data["SB2006_autoconversion_correcting_function_coeff_a"]["value"]), - FT(data["SB2006_autoconversion_correcting_function_coeff_b"]["value"]), - ) - accr = AccrSB2006( - FT(data["SB2006_collection_kernel_coeff_kcr"]["value"]), - FT(data["SB2006_accretion_correcting_function_coeff_tau0"]["value"]), - FT(data["SB2006_reference_air_density"]["value"]), - FT(data["SB2006_accretion_correcting_function_coeff_c"]["value"]), - ) - self = SelfColSB2006( - FT(data["SB2006_collection_kernel_coeff_krr"]["value"]), - FT(data["SB2006_collection_kernel_coeff_kapparr"]["value"]), - FT(data["SB2006_raindrops_self-collection_coeff_d"]["value"]), - ) - brek = BreakupSB2006( - FT(data["SB2006_raindrops_equlibrium_mean_diameter"]["value"]), - FT(data["SB2006_raindrops_breakup_mean_diameter_threshold"]["value"]), - FT(data["SB2006_raindrops_breakup_coeff_kbr"]["value"]), - FT(data["SB2006_raindrops_breakup_coeff_kappabr"]["value"]), - ) - evap = EvaporationSB2006( - FT(data["SB2006_ventilation_factor_coeff_av"]["value"]), - FT(data["SB2006_ventilation_factor_coeff_bv"]["value"]), - FT(data["SB2006_rain_evaportation_coeff_alpha"]["value"]), - FT(data["SB2006_rain_evaportation_coeff_beta"]["value"]), - FT(data["SB2006_reference_air_density"]["value"]), - ) - return SB2006{ - FT, - typeof(pdf), - typeof(acnv), - typeof(accr), - typeof(self), - typeof(brek), - typeof(evap), - }( - pdf, - acnv, - accr, - self, - brek, - evap, - ) +SB2006(::Type{FT}) where {FT <: AbstractFloat} = SB2006(CP.create_toml_dict(FT)) + +function SB2006(toml_dict::CP.AbstractTOMLDict) + pdf = ParticlePDF_SB2006(toml_dict) + acnv = AcnvSB2006(toml_dict) + accr = AccrSB2006(toml_dict) + self = SelfColSB2006(toml_dict) + brek = BreakupSB2006(toml_dict) + evap = EvaporationSB2006(toml_dict) + FT = CP.float_type(toml_dict) + PD = typeof(pdf) + AN = typeof(acnv) + AR = typeof(accr) + SE = typeof(self) + BR = typeof(brek) + EV = typeof(evap) + return SB2006{FT, PD, AN, AR, SE, BR, EV}(pdf, acnv, accr, self, brek, evap) end diff --git a/src/parameters/MicrophysicsP3.jl b/src/parameters/MicrophysicsP3.jl index 58441b109..773ee57db 100644 --- a/src/parameters/MicrophysicsP3.jl +++ b/src/parameters/MicrophysicsP3.jl @@ -9,7 +9,7 @@ Morrison and Milbrandt 2015 doi: 10.1175/JAS-D-14-0065.1 # Fields $(DocStringExtensions.FIELDS) """ -struct ParametersP3{FT} <: ParametersType{FT} +Base.@kwdef struct ParametersP3{FT} <: ParametersType{FT} "Coefficient in mass(size) relation [g/μm^β_va]" α_va::FT "Coefficient in mass(size) relation [-]" @@ -32,21 +32,23 @@ struct ParametersP3{FT} <: ParametersType{FT} μ_max::FT end -function ParametersP3( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return ParametersP3( - FT(data["BF1995_mass_coeff_alpha"]["value"]), - FT(data["BF1995_mass_exponent_beta"]["value"]), - FT(data["density_ice_water"]["value"]), - FT(data["density_liquid_water"]["value"]), - FT(data["M1996_area_coeff_gamma"]["value"]), - FT(data["M1996_area_exponent_sigma"]["value"]), - FT(data["Heymsfield_mu_coeff1"]["value"]), - FT(data["Heymsfield_mu_coeff2"]["value"]), - FT(data["Heymsfield_mu_coeff3"]["value"]), - FT(data["Heymsfield_mu_cutoff"]["value"]), +ParametersP3(::Type{FT}) where {FT <: AbstractFloat} = + ParametersP3(CP.create_toml_dict(FT)) + +function ParametersP3(td::CP.AbstractTOMLDict) + name_map = (; + :BF1995_mass_coeff_alpha => :α_va, + :BF1995_mass_exponent_beta => :β_va, + :density_ice_water => :ρ_i, + :density_liquid_water => :ρ_l, + :M1996_area_coeff_gamma => :γ, + :M1996_area_exponent_sigma => :σ, + :Heymsfield_mu_coeff1 => :a, + :Heymsfield_mu_coeff2 => :b, + :Heymsfield_mu_coeff3 => :c, + :Heymsfield_mu_cutoff => :μ_max, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return ParametersP3{FT}(; parameters...) end diff --git a/src/parameters/TerminalVelocity.jl b/src/parameters/TerminalVelocity.jl index 6a199f868..dbf82e7c1 100644 --- a/src/parameters/TerminalVelocity.jl +++ b/src/parameters/TerminalVelocity.jl @@ -9,7 +9,7 @@ for rain # Fields $(DocStringExtensions.FIELDS) """ -struct Blk1MVelTypeRain{FT} <: ParametersType{FT} +Base.@kwdef struct Blk1MVelTypeRain{FT} <: ParametersType{FT} "particle length scale [m]" r0::FT "rain terminal velocity size relation coefficient [-]" @@ -26,26 +26,19 @@ struct Blk1MVelTypeRain{FT} <: ParametersType{FT} grav::FT end -function Blk1MVelTypeRain( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return Blk1MVelTypeRain( - FT(data["snow_flake_length_scale"]["value"]), - FT( - data["rain_terminal_velocity_size_relation_coefficient_ve"]["value"], - ), - FT( - data["rain_terminal_velocity_size_relation_coefficient_delv"]["value"], - ), - FT( - data["rain_terminal_velocity_size_relation_coefficient_chiv"]["value"], - ), - FT(data["density_liquid_water"]["value"]), - FT(data["rain_drop_drag_coefficient"]["value"]), - FT(data["gravitational_acceleration"]["value"]), +function Blk1MVelTypeRain(td::CP.AbstractTOMLDict) + name_map = (; + :snow_flake_length_scale => :r0, + :rain_terminal_velocity_size_relation_coefficient_ve => :ve, + :rain_terminal_velocity_size_relation_coefficient_delv => :Δv, + :rain_terminal_velocity_size_relation_coefficient_chiv => :χv, + :density_liquid_water => :ρw, + :rain_drop_drag_coefficient => :C_drag, + :gravitational_acceleration => :grav, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Blk1MVelTypeRain{FT}(; parameters...) end """ @@ -57,7 +50,7 @@ for snow # Fields $(DocStringExtensions.FIELDS) """ -struct Blk1MVelTypeSnow{FT} <: ParametersType{FT} +Base.@kwdef struct Blk1MVelTypeSnow{FT} <: ParametersType{FT} "particle length scale [m]" r0::FT "snow terminal velocity size relation coefficient [-]" @@ -70,24 +63,18 @@ struct Blk1MVelTypeSnow{FT} <: ParametersType{FT} v0::FT end -function Blk1MVelTypeSnow( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - r0 = FT(data["snow_flake_length_scale"]["value"]) - ve = FT(data["snow_terminal_velocity_size_relation_coefficient"]["value"]) - return Blk1MVelTypeSnow( - r0, - ve, - FT( - data["snow_terminal_velocity_size_relation_coefficient_delv"]["value"], - ), - FT( - data["snow_terminal_velocity_size_relation_coefficient_chiv"]["value"], - ), - FT(2^(9 / 4)) * r0^ve, +function Blk1MVelTypeSnow(td::CP.AbstractTOMLDict) + name_map = (; + :snow_flake_length_scale => :r0, + :snow_terminal_velocity_size_relation_coefficient => :ve, + :snow_terminal_velocity_size_relation_coefficient_delv => :Δv, + :snow_terminal_velocity_size_relation_coefficient_chiv => :χv, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + + v0 = 2^(9 / 4) * parameters.r0^parameters.ve + FT = CP.float_type(td) + return Blk1MVelTypeSnow{FT}(; parameters..., v0) end """ @@ -108,8 +95,8 @@ function Blk1MVelType( ::Type{FT}, toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), ) where {FT} - rain = Blk1MVelTypeRain(FT, toml_dict) - snow = Blk1MVelTypeSnow(FT, toml_dict) + rain = Blk1MVelTypeRain(toml_dict) + snow = Blk1MVelTypeSnow(toml_dict) return Blk1MVelType{FT, typeof(rain), typeof(snow)}(rain, snow) end @@ -123,24 +110,26 @@ The type for precipitation terminal velocity from Seifert and Beheng 2006 # Fields $(DocStringExtensions.FIELDS) """ -struct SB2006VelType{FT} <: TerminalVelocityType{FT} +Base.@kwdef struct SB2006VelType{FT} <: TerminalVelocityType{FT} ρ0::FT aR::FT bR::FT cR::FT end -function SB2006VelType( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return SB2006VelType( - FT(data["SB2006_reference_air_density"]["value"]), - FT(data["SB2006_raindrops_terminal_velocity_coeff_aR"]["value"]), - FT(data["SB2006_raindrops_terminal_velocity_coeff_bR"]["value"]), - FT(data["SB2006_raindrops_terminal_velocity_coeff_cR"]["value"]), +SB2006VelType(::Type{FT}) where {FT <: AbstractFloat} = + SB2006VelType(CP.create_toml_dict(FT)) + +function SB2006VelType(td::CP.AbstractTOMLDict) + name_map = (; + :SB2006_reference_air_density => :ρ0, + :SB2006_raindrops_terminal_velocity_coeff_aR => :aR, + :SB2006_raindrops_terminal_velocity_coeff_bR => :bR, + :SB2006_raindrops_terminal_velocity_coeff_cR => :cR, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return SB2006VelType{FT}(; parameters...) end """ @@ -164,51 +153,40 @@ struct Chen2022VelTypeSnowIce{FT} <: ParametersType{FT} ρᵢ::FT end -function Chen2022VelTypeSnowIce( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - A = ( - FT(data["Chen2022_table_B3_As_coeff_1"]["value"]), - FT(data["Chen2022_table_B3_As_coeff_2"]["value"]), - FT(data["Chen2022_table_B3_As_coeff_3"]["value"]), - ) - B = ( - FT(data["Chen2022_table_B3_Bs_coeff_1"]["value"]), - FT(data["Chen2022_table_B3_Bs_coeff_2"]["value"]), - FT(data["Chen2022_table_B3_Bs_coeff_3"]["value"]), - ) - C = ( - FT(data["Chen2022_table_B3_Cs_coeff_1"]["value"]), - FT(data["Chen2022_table_B3_Cs_coeff_2"]["value"]), - FT(data["Chen2022_table_B3_Cs_coeff_3"]["value"]), - FT(data["Chen2022_table_B3_Cs_coeff_4"]["value"]), - ) - E = ( - FT(data["Chen2022_table_B3_Es_coeff_1"]["value"]), - FT(data["Chen2022_table_B3_Es_coeff_2"]["value"]), - FT(data["Chen2022_table_B3_Es_coeff_3"]["value"]), - ) - F = ( - FT(data["Chen2022_table_B3_Fs_coeff_1"]["value"]), - FT(data["Chen2022_table_B3_Fs_coeff_2"]["value"]), - FT(data["Chen2022_table_B3_Fs_coeff_3"]["value"]), +function Chen2022VelTypeSnowIce(toml_dict::CP.AbstractTOMLDict) + # TODO: These should be array parameters. + name_map = (; + :Chen2022_table_B3_As_coeff_1 => :A1, + :Chen2022_table_B3_As_coeff_2 => :A2, + :Chen2022_table_B3_As_coeff_3 => :A3, + :Chen2022_table_B3_Bs_coeff_1 => :B1, + :Chen2022_table_B3_Bs_coeff_2 => :B2, + :Chen2022_table_B3_Bs_coeff_3 => :B3, + :Chen2022_table_B3_Cs_coeff_1 => :C1, + :Chen2022_table_B3_Cs_coeff_2 => :C2, + :Chen2022_table_B3_Cs_coeff_3 => :C3, + :Chen2022_table_B3_Cs_coeff_4 => :C4, + :Chen2022_table_B3_Es_coeff_1 => :E1, + :Chen2022_table_B3_Es_coeff_2 => :E2, + :Chen2022_table_B3_Es_coeff_3 => :E3, + :Chen2022_table_B3_Fs_coeff_1 => :F1, + :Chen2022_table_B3_Fs_coeff_2 => :F2, + :Chen2022_table_B3_Fs_coeff_3 => :F3, + :Chen2022_table_B3_Gs_coeff_1 => :G1, + :Chen2022_table_B3_Gs_coeff_2 => :G2, + :Chen2022_table_B3_Gs_coeff_3 => :G3, + :density_ice_water => :ρᵢ, ) - G = ( - FT(data["Chen2022_table_B3_Gs_coeff_1"]["value"]), - FT(data["Chen2022_table_B3_Gs_coeff_2"]["value"]), - FT(data["Chen2022_table_B3_Gs_coeff_3"]["value"]), - ) - ρᵢ = FT(data["density_ice_water"]["value"]) - return Chen2022VelTypeSnowIce( - A[1] * (log(ρᵢ))^2 − A[2] * log(ρᵢ) - A[3], - FT(1) / (B[1] + B[2] * log(ρᵢ) + B[3] / sqrt(ρᵢ)), - C[1] + C[2] * exp(C[3] * ρᵢ) + C[4] * sqrt(ρᵢ), - E[1] - E[2] * (log(ρᵢ))^2 + E[3] * sqrt(ρᵢ), - -exp(F[1] - F[2] * (log(ρᵢ))^2 + F[3] * log(ρᵢ)), - FT(1) / (G[1] + G[2] / (log(ρᵢ)) - G[3] * log(ρᵢ) / ρᵢ), - ρᵢ, + p = CP.get_parameter_values(toml_dict, name_map, "CloudMicrophysics") + FT = CP.float_type(toml_dict) + return Chen2022VelTypeSnowIce{FT}( + p.A1 * (log(p.ρᵢ))^2 − p.A2 * log(p.ρᵢ) - p.A3, + FT(1) / (p.B1 + p.B2 * log(p.ρᵢ) + p.B3 / sqrt(p.ρᵢ)), + p.C1 + p.C2 * exp(p.C3 * p.ρᵢ) + p.C4 * sqrt(p.ρᵢ), + p.E1 - p.E2 * (log(p.ρᵢ))^2 + p.E3 * sqrt(p.ρᵢ), + -exp(p.F1 - p.F2 * (log(p.ρᵢ))^2 + p.F3 * log(p.ρᵢ)), + FT(1) / (p.G1 + p.G2 / (log(p.ρᵢ)) - p.G3 * log(p.ρᵢ) / p.ρᵢ), + p.ρᵢ, ) end @@ -222,7 +200,7 @@ DOI: 10.1016/j.atmosres.2022.106171 # Fields $(DocStringExtensions.FIELDS) """ -struct Chen2022VelTypeRain{FT} <: ParametersType{FT} +Base.@kwdef struct Chen2022VelTypeRain{FT} <: ParametersType{FT} ρ0::FT a1::FT a2::FT @@ -237,39 +215,27 @@ struct Chen2022VelTypeRain{FT} <: ParametersType{FT} c3::FT end -function Chen2022VelTypeRain( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - ρ0 = FT(data["Chen2022_table_B1_q_coeff"]["value"]) - a1 = FT(data["Chen2022_table_B1_a1_coeff"]["value"]) - a2 = FT(data["Chen2022_table_B1_a2_coeff"]["value"]) - a3 = FT(data["Chen2022_table_B1_a3_coeff"]["value"]) - a3_pow = FT(data["Chen2022_table_B1_a3_pow_coeff"]["value"]) - - b1 = FT(data["Chen2022_table_B1_b1_coeff"]["value"]) - b2 = FT(data["Chen2022_table_B1_b2_coeff"]["value"]) - b3 = FT(data["Chen2022_table_B1_b3_coeff"]["value"]) - b_ρ = FT(data["Chen2022_table_B1_b_rho_coeff"]["value"]) - - c1 = FT(data["Chen2022_table_B1_c1_coeff"]["value"]) - c2 = FT(data["Chen2022_table_B1_c2_coeff"]["value"]) - c3 = FT(data["Chen2022_table_B1_c3_coeff"]["value"]) - return Chen2022VelTypeRain( - ρ0, - a1, - a2, - a3, - a3_pow, - b1, - b2, - b3, - b_ρ, - c1, - c2, - c3, +Chen2022VelTypeRain(::Type{FT}) where {FT <: AbstractFloat} = + Chen2022VelTypeRain(CP.create_toml_dict(FT)) + +function Chen2022VelTypeRain(td::CP.AbstractTOMLDict) + name_map = (; + :Chen2022_table_B1_q_coeff => :ρ0, + :Chen2022_table_B1_a1_coeff => :a1, + :Chen2022_table_B1_a2_coeff => :a2, + :Chen2022_table_B1_a3_coeff => :a3, + :Chen2022_table_B1_a3_pow_coeff => :a3_pow, + :Chen2022_table_B1_b1_coeff => :b1, + :Chen2022_table_B1_b2_coeff => :b2, + :Chen2022_table_B1_b3_coeff => :b3, + :Chen2022_table_B1_b_rho_coeff => :b_ρ, + :Chen2022_table_B1_c1_coeff => :c1, + :Chen2022_table_B1_c2_coeff => :c2, + :Chen2022_table_B1_c3_coeff => :c3, ) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return Chen2022VelTypeRain{FT}(; parameters...) end """ @@ -291,7 +257,7 @@ function Chen2022VelType( ::Type{FT}, toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), ) where {FT} - rain = Chen2022VelTypeRain(FT, toml_dict) - snow_ice = Chen2022VelTypeSnowIce(FT, toml_dict) + rain = Chen2022VelTypeRain(toml_dict) + snow_ice = Chen2022VelTypeSnowIce(toml_dict) return Chen2022VelType{FT, typeof(rain), typeof(snow_ice)}(rain, snow_ice) end diff --git a/src/parameters/WaterProperties.jl b/src/parameters/WaterProperties.jl index a53e32949..7bded6b05 100644 --- a/src/parameters/WaterProperties.jl +++ b/src/parameters/WaterProperties.jl @@ -8,20 +8,19 @@ Parameters with water properties. # Fields $(DocStringExtensions.FIELDS) """ -struct WaterProperties{FT} <: ParametersType{FT} +Base.@kwdef struct WaterProperties{FT} <: ParametersType{FT} "density of liquid water [kg/m3]" ρw::FT "density of ice [kg/m3]" ρi::FT end -function WaterProperties( - ::Type{FT}, - toml_dict::CP.AbstractTOMLDict = CP.create_toml_dict(FT), -) where {FT} - (; data) = toml_dict - return WaterProperties( - FT(data["density_liquid_water"]["value"]), - FT(data["density_ice_water"]["value"]), - ) +WaterProperties(::Type{FT}) where {FT <: AbstractFloat} = + WaterProperties(CP.create_toml_dict(FT)) + +function WaterProperties(td::CP.AbstractTOMLDict) + name_map = (; :density_liquid_water => :ρw, :density_ice_water => :ρi) + parameters = CP.get_parameter_values(td, name_map, "CloudMicrophysics") + FT = CP.float_type(td) + return WaterProperties{FT}(; parameters...) end