introduce multiple choices for activation criteria in ActivableFraction product; sanitize saturation vs. supersaturation naming and units across the codebase (#1595)

Co-authored-by: AgnieszkaZaba <[email protected]>
Co-authored-by: Agnieszka Żaba <[email protected]>

Author: slayoo

PySDM/attributes/impl/__init__.py

@@ -11,3 +11,4 @@
 from .maximum_attribute import MaximumAttribute
 from .attribute_registry import register_attribute, get_attribute_class
 from .intensive_attribute import IntensiveAttribute
+from .temperature_variation_option_attribute import TemperatureVariationOptionAttribute

PySDM/attributes/impl/temperature_variation_option_attribute.py

@@ -0,0 +1,18 @@
+"""common code for attributes offering an option to neglect temperature variation,
+intended for use with Parcel environment only"""
+
+
+class TemperatureVariationOptionAttribute:  # pylint: disable=too-few-public-methods
+    """base class"""
+
+    def __init__(self, builder, neglect_temperature_variations: bool):
+        if neglect_temperature_variations:
+            assert builder.particulator.environment.mesh.dimension == 0
+        self.neglect_temperature_variations = neglect_temperature_variations
+        self.initial_temperature = (
+            builder.particulator.Storage.from_ndarray(
+                builder.particulator.environment["T"].to_ndarray()
+            )
+            if neglect_temperature_variations
+            else None
+        )

PySDM/attributes/physics/__init__.py

@@ -3,11 +3,11 @@
 """
 
 from .area import Area
-from .critical_supersaturation import CriticalSupersaturation
+from .critical_saturation import CriticalSaturation
 from .critical_volume import CriticalVolume, WetToCriticalVolumeRatio
 from .dry_radius import DryRadius
 from .dry_volume import DryVolume
-from .equilibrium_supersaturation import EquilibriumSupersaturation
+from .equilibrium_saturation import EquilibriumSaturation
 from .heat import Heat
 from .hygroscopicity import Kappa, KappaTimesDryVolume
 from .water_mass import SignedWaterMass

PySDM/attributes/physics/critical_saturation.py

@@ -0,0 +1,54 @@
+"""
+kappa-Koehler critical saturation calculated for either initial or actual environment temperature
+"""
+
+from PySDM.attributes.impl import (
+    DerivedAttribute,
+    register_attribute,
+    TemperatureVariationOptionAttribute,
+)
+
+
+@register_attribute()
+class CriticalSaturation(DerivedAttribute, TemperatureVariationOptionAttribute):
+    def __init__(self, builder, neglect_temperature_variations=False):
+        assert builder.particulator.mesh.dimension == 0
+
+        self.v_crit = builder.get_attribute("critical volume")
+        self.v_dry = builder.get_attribute("dry volume")
+        self.kappa = builder.get_attribute("kappa")
+        self.f_org = builder.get_attribute("dry volume organic fraction")
+        TemperatureVariationOptionAttribute.__init__(
+            self, builder, neglect_temperature_variations
+        )
+        DerivedAttribute.__init__(
+            self,
+            builder=builder,
+            name="critical saturation",
+            dependencies=(self.v_crit, self.kappa, self.v_dry, self.f_org),
+        )
+
+    def recalculate(self):
+        temperature = (
+            self.initial_temperature
+            if self.neglect_temperature_variations
+            else self.particulator.environment["T"]
+        )
+        r_cr = self.formulae.trivia.radius(self.v_crit.data.data)
+        rd3 = self.v_dry.data.data / self.formulae.constants.PI_4_3
+        sgm = self.formulae.surface_tension.sigma(
+            temperature.data,
+            self.v_crit.data.data,
+            self.v_dry.data.data,
+            self.f_org.data.data,
+        )
+
+        self.data.data[:] = self.formulae.hygroscopicity.RH_eq(
+            r_cr, T=temperature.data, kp=self.kappa.data.data, rd3=rd3, sgm=sgm
+        )
+
+
+@register_attribute()
+class CriticalSaturationNeglectingTemperatureVariations(CriticalSaturation):
+    def __init__(self, builder):
+        super().__init__(builder, neglect_temperature_variations=True)

PySDM/attributes/physics/critical_supersaturation.py

@@ -1,45 +1,88 @@
 """
-critical wet volume (kappa-Koehler, computed using actual temperature)
+critical wet volume (kappa-Koehler, computed using actual or initial temperature)
 """
 
-from PySDM.attributes.impl import DerivedAttribute, register_attribute
+from PySDM.attributes.impl import (
+    DerivedAttribute,
+    register_attribute,
+    TemperatureVariationOptionAttribute,
+)
 
 
 @register_attribute()
-class CriticalVolume(DerivedAttribute):
-    def __init__(self, builder):
+class CriticalVolume(DerivedAttribute, TemperatureVariationOptionAttribute):
+    def __init__(self, builder, neglect_temperature_variations=False):
         self.cell_id = builder.get_attribute("cell id")
         self.v_dry = builder.get_attribute("dry volume")
         self.v_wet = builder.get_attribute("volume")
         self.kappa = builder.get_attribute("kappa")
         self.f_org = builder.get_attribute("dry volume organic fraction")
         self.environment = builder.particulator.environment
         self.particles = builder.particulator
+
         dependencies = [self.v_dry, self.v_wet, self.cell_id]
-        super().__init__(builder, name="critical volume", dependencies=dependencies)
+        TemperatureVariationOptionAttribute.__init__(
+            self, builder, neglect_temperature_variations
+        )
+        DerivedAttribute.__init__(
+            self, builder, name="critical volume", dependencies=dependencies
+        )
 
     def recalculate(self):
+        temperature = (
+            self.initial_temperature
+            if self.neglect_temperature_variations
+            else self.environment["T"]
+        )
         self.particulator.backend.critical_volume(
             v_cr=self.data,
             kappa=self.kappa.get(),
             f_org=self.f_org.get(),
             v_dry=self.v_dry.get(),
             v_wet=self.v_wet.get(),
-            T=self.environment["T"],
+            T=temperature,
             cell=self.cell_id.get(),
         )
 
 
 @register_attribute()
-class WetToCriticalVolumeRatio(DerivedAttribute):
+class CriticalVolumeNeglectingTemperatureVariations(CriticalVolume):
     def __init__(self, builder):
-        self.critical_volume = builder.get_attribute("critical volume")
+        super().__init__(builder, neglect_temperature_variations=True)
+
+
+@register_attribute()
+class WetToCriticalVolumeRatio(DerivedAttribute):
+    def __init__(
+        self,
+        builder,
+        neglect_temperature_variations=False,
+        name="wet to critical volume ratio",
+    ):
+        self.critical_volume = builder.get_attribute(
+            "critical volume"
+            + (
+                " neglecting temperature variations"
+                if neglect_temperature_variations
+                else ""
+            )
+        )
         self.volume = builder.get_attribute("volume")
         super().__init__(
             builder,
-            name="wet to critical volume ratio",
+            name=name,
             dependencies=(self.critical_volume, self.volume),
         )
 
     def recalculate(self):
         self.data.ratio(self.volume.get(), self.critical_volume.get())
+
+
+@register_attribute()
+class WetToCriticalVolumeRatioNeglectingTemperatureVariations(WetToCriticalVolumeRatio):
+    def __init__(self, builder):
+        super().__init__(
+            builder,
+            neglect_temperature_variations=True,
+            name="wet to critical volume ratio neglecting temperature variations",
+        )

PySDM/attributes/physics/critical_volume.py

@@ -1,12 +1,12 @@
 """
-kappa-Koehler equilibrium supersaturation calculated for actual environment temperature
+kappa-Koehler equilibrium saturation calculated for actual environment temperature
 """
 
 from PySDM.attributes.impl import DerivedAttribute, register_attribute
 
 
 @register_attribute()
-class EquilibriumSupersaturation(DerivedAttribute):
+class EquilibriumSaturation(DerivedAttribute):
     def __init__(self, builder):
         self.r_wet = builder.get_attribute("radius")
         self.v_wet = builder.get_attribute("volume")
@@ -16,7 +16,7 @@ def __init__(self, builder):
 
         super().__init__(
             builder=builder,
-            name="equilibrium supersaturation",
+            name="equilibrium saturation",
             dependencies=(self.kappa, self.v_dry, self.f_org, self.r_wet),
         )
 

PySDM/attributes/physics/equilibrium_supersaturation.py renamed to PySDM/attributes/physics/equilibrium_saturation.py

@@ -2,7 +2,7 @@
 Zero-dimensional adiabatic parcel framework
 """
 
-from typing import List, Optional
+from typing import List, Optional, Union
 
 import numpy as np
 
@@ -25,7 +25,7 @@ def __init__(
         p0: float,
         initial_water_vapour_mixing_ratio: float,
         T0: float,
-        w: [float, callable],
+        w: Union[float, callable],
         z0: float = 0,
         mixed_phase=False,
         variables: Optional[List[str]] = None,

PySDM/environments/parcel.py

@@ -5,4 +5,4 @@
 from .activable_fraction import ActivableFraction
 from .condensation_timestep import CondensationTimestepMax, CondensationTimestepMin
 from .event_rates import ActivatingRate, DeactivatingRate, RipeningRate
-from .peak_supersaturation import PeakSupersaturation
+from .peak_saturation import PeakSaturation

PySDM/products/condensation/__init__.py

@@ -1,27 +1,38 @@
 """
-fraction of particles with critical supersaturation lower than a given supersaturation
+fraction of particles with critical saturation lower than a given saturation
  (passed as keyword argument while calling `get()`)
 """
 
+import numpy as np
 from PySDM.products.impl import MomentProduct, register_product
 
 
 @register_product()
 class ActivableFraction(MomentProduct):
-    def __init__(self, unit="dimensionless", name=None):
+    def __init__(
+        self, unit="dimensionless", name=None, filter_attr="critical saturation"
+    ):
         super().__init__(name=name, unit=unit)
+        self.filter_attr = filter_attr
 
     def register(self, builder):
         super().register(builder)
-        builder.request_attribute("critical supersaturation")
+        builder.request_attribute(self.filter_attr)
 
     def _impl(self, **kwargs):
-        s_max = kwargs["S_max"]
+        if self.filter_attr.startswith("critical saturation"):
+            s_max = kwargs["S_max"]
+            assert not np.isfinite(s_max) or 0 < s_max < 1.1
+            filter_range = (0, s_max)
+        elif self.filter_attr.startswith("wet to critical volume ratio"):
+            filter_range = (1, np.inf)
+        else:
+            assert False
         self._download_moment_to_buffer(
             attr="volume",
             rank=0,
-            filter_range=(0, 1 + s_max / 100),
-            filter_attr="critical supersaturation",
+            filter_range=filter_range,
+            filter_attr=self.filter_attr,
         )
         frac = self.buffer.copy()
         self._download_moment_to_buffer(attr="volume", rank=0)