PySDM 2.101__tar.gz → 2.102__tar.gz

{pysdm-2.101 → pysdm-2.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.101
+Version: 2.102
 Summary: Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab
 Home-page: https://github.com/open-atmos/PySDM
 Author: https://github.com/open-atmos/PySDM/graphs/contributors

{pysdm-2.101 → pysdm-2.102}/PySDM/attributes/isotopes/moles.py

@@ -62,7 +62,7 @@ class MolesLightWater(Helper):
                 / M_H2O,
                 builder.get_attribute("moles_18O"): -(2 * const.M_1H + const.M_18O)
                 / M_H2O,
-                builder.get_attribute("water mass"): 1 / M_H2O,
+                builder.get_attribute("signed water mass"): 1 / M_H2O,
             },
         )
 

{pysdm-2.101 → pysdm-2.102}/PySDM/attributes/physics/__init__.py

@@ -10,7 +10,7 @@ from .dry_volume import DryVolume
 from .equilibrium_supersaturation import EquilibriumSupersaturation
 from .heat import Heat
 from .hygroscopicity import Kappa, KappaTimesDryVolume
-from .water_mass import WaterMass
+from .water_mass import SignedWaterMass
 from .multiplicity import Multiplicity
 from .radius import Radius, SquareRootOfRadius
 from .relative_fall_velocity import RelativeFallMomentum, RelativeFallVelocity

pysdm-2.102/PySDM/attributes/physics/water_mass.py

@@ -0,0 +1,63 @@
+"""
+particle mass attributes
+in simulations involving mixed-phase clouds, positive values correspond to
+liquid water and negative values to ice
+"""
+
+from PySDM.attributes.impl import (
+    ExtensiveAttribute,
+    DerivedAttribute,
+    register_attribute,
+)
+
+
+@register_attribute()
+class SignedWaterMass(ExtensiveAttribute):
+    def __init__(self, builder):
+        super().__init__(builder, name="signed water mass")
+
+
+@register_attribute(
+    name="water mass",
+    variant=lambda _, formulae: not formulae.particle_shape_and_density.supports_mixed_phase(),
+)
+class ViewWaterMass(DerivedAttribute):
+    def __init__(self, builder):
+        self.signed_water_mass = builder.get_attribute("signed water mass")
+
+        super().__init__(
+            builder,
+            name="water mass",
+            dependencies=(self.signed_water_mass,),
+        )
+
+    def mark_updated(self):
+        self.signed_water_mass.mark_updated()
+
+    def allocate(self, idx):
+        pass
+
+    def recalculate(self):
+        pass
+
+    def get(self):
+        return self.signed_water_mass.data
+
+
+@register_attribute(
+    name="water mass",
+    variant=lambda _, formulae: formulae.particle_shape_and_density.supports_mixed_phase(),
+)
+class AbsWaterMass(DerivedAttribute):
+    def __init__(self, builder):
+        self.signed_water_mass = builder.get_attribute("signed water mass")
+
+        super().__init__(
+            builder,
+            name="water mass",
+            dependencies=(self.signed_water_mass,),
+        )
+
+    def recalculate(self):
+        self.data.fill(self.signed_water_mass.data)
+        self.data.abs()

{pysdm-2.101 → pysdm-2.102}/PySDM/backends/impl_common/freezing_attributes.py

@@ -1,12 +1,15 @@
 """
-groups of attributes used in either singular or time-dependent immmersion freezing regimes
+groups of attributes used in either singular or time-dependent immersion freezing regimes
 """
 
 from collections import namedtuple
 
 
 class SingularAttributes(
-    namedtuple("SingularAttributes", ("freezing_temperature", "water_mass"))
+    namedtuple(
+        typename="SingularAttributes",
+        field_names=("freezing_temperature", "signed_water_mass"),
+    )
 ):
     """groups attributes required in singular regime"""
 
@@ -14,7 +17,10 @@ class SingularAttributes(
 
 
 class TimeDependentAttributes(
-    namedtuple("TimeDependentAttributes", ("immersed_surface_area", "water_mass"))
+    namedtuple(
+        typename="TimeDependentAttributes",
+        field_names=("immersed_surface_area", "signed_water_mass"),
+    )
 ):
     """groups attributes required in time-dependent regime"""
 

{pysdm-2.101 → pysdm-2.102}/PySDM/backends/impl_numba/methods/freezing_methods.py

@@ -39,16 +39,16 @@ class FreezingMethods(BackendMethods):
                 if attributes.freezing_temperature[i] == 0:
                     continue
                 if thaw and frozen_and_above_freezing_point(
-                    attributes.water_mass[i], temperature[cell[i]]
+                    attributes.signed_water_mass[i], temperature[cell[i]]
                 ):
-                    _thaw(attributes.water_mass, i)
+                    _thaw(attributes.signed_water_mass, i)
                 elif (
                     unfrozen_and_saturated(
-                        attributes.water_mass[i], relative_humidity[cell[i]]
+                        attributes.signed_water_mass[i], relative_humidity[cell[i]]
                     )
                     and temperature[cell[i]] <= attributes.freezing_temperature[i]
                 ):
-                    _freeze(attributes.water_mass, i)
+                    _freeze(attributes.signed_water_mass, i)
 
         self.freeze_singular_body = freeze_singular_body
 
@@ -68,17 +68,17 @@ class FreezingMethods(BackendMethods):
             freezing_temperature,
             thaw,
         ):
-            n_sd = len(attributes.water_mass)
+            n_sd = len(attributes.signed_water_mass)
             for i in numba.prange(n_sd):  # pylint: disable=not-an-iterable
                 if attributes.immersed_surface_area[i] == 0:
                     continue
                 cell_id = cell[i]
                 if thaw and frozen_and_above_freezing_point(
-                    attributes.water_mass[i], temperature[cell_id]
+                    attributes.signed_water_mass[i], temperature[cell_id]
                 ):
-                    _thaw(attributes.water_mass, i)
+                    _thaw(attributes.signed_water_mass, i)
                 elif unfrozen_and_saturated(
-                    attributes.water_mass[i], relative_humidity[cell_id]
+                    attributes.signed_water_mass[i], relative_humidity[cell_id]
                 ):
                     rate_assuming_constant_temperature_within_dt = (
                         j_het(a_w_ice[cell_id]) * attributes.immersed_surface_area[i]
@@ -87,7 +87,7 @@ class FreezingMethods(BackendMethods):
                         r=rate_assuming_constant_temperature_within_dt, dt=timestep
                     )
                     if rand[i] < prob:
-                        _freeze(attributes.water_mass, i)
+                        _freeze(attributes.signed_water_mass, i)
                         # if record_freezing_temperature:
                         #     freezing_temperature[i] = temperature[cell_id]
 
@@ -99,7 +99,7 @@ class FreezingMethods(BackendMethods):
         self.freeze_singular_body(
             SingularAttributes(
                 freezing_temperature=attributes.freezing_temperature.data,
-                water_mass=attributes.water_mass.data,
+                signed_water_mass=attributes.signed_water_mass.data,
             ),
             temperature.data,
             relative_humidity.data,
@@ -125,7 +125,7 @@ class FreezingMethods(BackendMethods):
             rand.data,
             TimeDependentAttributes(
                 immersed_surface_area=attributes.immersed_surface_area.data,
-                water_mass=attributes.water_mass.data,
+                signed_water_mass=attributes.signed_water_mass.data,
             ),
             timestep,
             cell.data,

{pysdm-2.101 → pysdm-2.102}/PySDM/backends/impl_numba/storage.py

@@ -208,3 +208,6 @@ class Storage(StorageBase):
 
     def exp(self):
         self.data[:] = np.exp(self.data)
+
+    def abs(self):
+        self.data[:] = np.abs(self.data)

{pysdm-2.101 → pysdm-2.102}/PySDM/backends/impl_thrust_rtc/methods/freezing_methods.py

@@ -18,7 +18,7 @@ class FreezingMethods(ThrustRTCBackendMethods):
             param_names=(
                 "rand",
                 "immersed_surface_area",
-                "water_mass",
+                "signed_water_mass",
                 "timestep",
                 "cell",
                 "a_w_ice",
@@ -32,12 +32,12 @@ class FreezingMethods(ThrustRTCBackendMethods):
                     return;
                 }}
                 if (thaw && {self.formulae.trivia.frozen_and_above_freezing_point.c_inline(
-                    water_mass="water_mass[i]",
+                    signed_water_mass="signed_water_mass[i]",
                     temperature="temperature[cell[i]]"
                 )}) {{
-                    water_mass[i] = -1 * water_mass[i];
+                    signed_water_mass[i] = -1 * signed_water_mass[i];
                 }} else if ({self.formulae.trivia.unfrozen_and_saturated.c_inline(
-                        water_mass="water_mass[i]",
+                        signed_water_mass="signed_water_mass[i]",
                         relative_humidity="relative_humidity[cell[i]]"
                     )}) {{
                     auto rate_assuming_constant_temperature_within_dt = {self.formulae.heterogeneous_ice_nucleation_rate.j_het.c_inline(
@@ -48,7 +48,7 @@ class FreezingMethods(ThrustRTCBackendMethods):
                         dt="timestep"
                     )};
                     if (rand[i] < prob) {{
-                        water_mass[i] = -1 * water_mass[i];
+                        signed_water_mass[i] = -1 * signed_water_mass[i];
                     }}
                 }}
             """.replace(
@@ -61,7 +61,7 @@ class FreezingMethods(ThrustRTCBackendMethods):
         return trtc.For(
             param_names=(
                 "freezing_temperature",
-                "water_mass",
+                "signed_water_mass",
                 "temperature",
                 "relative_humidity",
                 "cell",
@@ -73,17 +73,17 @@ class FreezingMethods(ThrustRTCBackendMethods):
                     return;
                 }}
                 if (thaw && {self.formulae.trivia.frozen_and_above_freezing_point.c_inline(
-                    water_mass="water_mass[i]",
+                    signed_water_mass="signed_water_mass[i]",
                     temperature="temperature[cell[i]]"
                 )}) {{
-                    water_mass[i] = -1 * water_mass[i];
+                    signed_water_mass[i] = -1 * signed_water_mass[i];
                 }} else if (
                     {self.formulae.trivia.unfrozen_and_saturated.c_inline(
-                        water_mass="water_mass[i]",
+                        signed_water_mass="signed_water_mass[i]",
                         relative_humidity="relative_humidity[cell[i]]"
                     )} && temperature[cell[i]] <= freezing_temperature[i]
                 ) {{
-                    water_mass[i] = -1 * water_mass[i];
+                    signed_water_mass[i] = -1 * signed_water_mass[i];
                 }}
             """.replace(
                 "real_type", self._get_c_type()
@@ -99,7 +99,7 @@ class FreezingMethods(ThrustRTCBackendMethods):
             n=n_sd,
             args=(
                 attributes.freezing_temperature.data,
-                attributes.water_mass.data,
+                attributes.signed_water_mass.data,
                 temperature.data,
                 relative_humidity.data,
                 cell.data,
@@ -128,7 +128,7 @@ class FreezingMethods(ThrustRTCBackendMethods):
             args=(
                 rand.data,
                 attributes.immersed_surface_area.data,
-                attributes.water_mass.data,
+                attributes.signed_water_mass.data,
                 self._get_floating_point(timestep),
                 cell.data,
                 a_w_ice.data,

{pysdm-2.101 → pysdm-2.102}/PySDM/backends/impl_thrust_rtc/storage.py

@@ -319,6 +319,19 @@ def make_storage_class(BACKEND):  # pylint: disable=too-many-statements
         def exp(output):
             Impl.__exp_body.launch_n(output.shape[0], Impl.thrust((output,)))
 
+        __abs_body = trtc.For(
+            ("output",),
+            "i",
+            """
+                output[i] = abs(output[i]);
+            """,
+        )
+
+        @staticmethod
+        @nice_thrust(**NICE_THRUST_FLAGS)
+        def abs(output):
+            Impl.__abs_body.launch_n(output.shape[0], Impl.thrust((output,)))
+
     class Storage(StorageBase):
         FLOAT = BACKEND._get_np_dtype()
         INT = np.int64
@@ -554,4 +567,8 @@ def make_storage_class(BACKEND):  # pylint: disable=too-many-statements
             Impl.exp(self)
             return self
 
+        def abs(self):
+            Impl.abs(self)
+            return self
+
     return Storage

{pysdm-2.101 → pysdm-2.102}/PySDM/builder.py

@@ -109,12 +109,19 @@ class Builder:
             ), "implied volume-to-mass conversion is only supported for spherical particles"
             attributes["water mass"] = (
                 self.particulator.formulae.particle_shape_and_density.volume_to_mass(
-                    attributes["volume"]
+                    attributes.pop("volume")
                 )
             )
-            del attributes["volume"]
             self.request_attribute("volume")
 
+        if (
+            "water mass" in attributes
+            and "signed water mass" not in attributes
+            and not self.particulator.formulae.particle_shape_and_density.supports_mixed_phase()
+        ):
+            attributes["signed water mass"] = attributes.pop("water mass")
+            self.request_attribute("water mass")
+
         self.req_attr = {}
         for attr_name in self.req_attr_names:
             self._resolve_attribute(attr_name)

{pysdm-2.101 → pysdm-2.102}/PySDM/dynamics/freezing.py

@@ -27,7 +27,7 @@ class Freezing:
 
         assert builder.formulae.particle_shape_and_density.supports_mixed_phase()
 
-        builder.request_attribute("volume")
+        builder.request_attribute("signed water mass")
         if self.singular or self.record_freezing_temperature:
             builder.request_attribute("freezing temperature")
 
@@ -59,7 +59,7 @@ class Freezing:
                     freezing_temperature=self.particulator.attributes[
                         "freezing temperature"
                     ],
-                    water_mass=self.particulator.attributes["water mass"],
+                    signed_water_mass=self.particulator.attributes["signed water mass"],
                 ),
                 temperature=self.particulator.environment["T"],
                 relative_humidity=self.particulator.environment["RH"],
@@ -74,7 +74,7 @@ class Freezing:
                     immersed_surface_area=self.particulator.attributes[
                         "immersed surface area"
                     ],
-                    water_mass=self.particulator.attributes["water mass"],
+                    signed_water_mass=self.particulator.attributes["signed water mass"],
                 ),
                 timestep=self.particulator.dt,
                 cell=self.particulator.attributes["cell id"],
@@ -90,6 +90,6 @@ class Freezing:
                 thaw=self.thaw,
             )
 
-        self.particulator.attributes.mark_updated("water mass")
+        self.particulator.attributes.mark_updated("signed water mass")
         if self.record_freezing_temperature:
             self.particulator.attributes.mark_updated("freezing temperature")

{pysdm-2.101 → pysdm-2.102}/PySDM/environments/kinematic_2d.py

@@ -81,7 +81,9 @@ class Kinematic2D(Moist):
             domain_volume = np.prod(np.array(self.mesh.size))
 
         attributes["multiplicity"] = n_per_kg * rhod[cell_id] * domain_volume
-        attributes["volume"] = self.formulae.trivia.volume(radius=r_wet)
+        attributes["water mass"] = (
+            self.formulae.particle_shape_and_density.radius_to_mass(r_wet)
+        )
 
         return attributes
 

{pysdm-2.101 → pysdm-2.102}/PySDM/particulator.py

@@ -119,7 +119,7 @@ class Particulator:  # pylint: disable=too-many-public-methods,too-many-instance
             solver=self.condensation_solver,
             n_cell=self.mesh.n_cell,
             cell_start_arg=self.attributes.cell_start,
-            water_mass=self.attributes["water mass"],
+            water_mass=self.attributes["signed water mass"],
             multiplicity=self.attributes["multiplicity"],
             vdry=self.attributes["dry volume"],
             idx=self.attributes._ParticleAttributes__idx,
@@ -147,7 +147,7 @@ class Particulator:  # pylint: disable=too-many-public-methods,too-many-instance
             air_density=self.environment["air density"],
             air_dynamic_viscosity=self.environment["air dynamic viscosity"],
         )
-        self.attributes.mark_updated("water mass")
+        self.attributes.mark_updated("signed water mass")
 
     def collision_coalescence_breakup(
         self,

{pysdm-2.101 → pysdm-2.102}/PySDM/physics/particle_shape_and_density/mixed_phase_spheres.py

@@ -29,4 +29,7 @@ class MixedPhaseSpheres:
 
     @staticmethod
     def radius_to_mass(const, radius):
-        raise NotImplementedError()
+        return (
+            np.maximum(const.ZERO_VOLUME, const.PI_4_3 * radius**3) * const.rho_w
+            + np.minimum(const.ZERO_VOLUME, const.PI_4_3 * radius**3) * const.rho_i
+        )

{pysdm-2.101 → pysdm-2.102}/PySDM/physics/trivia.py

@@ -76,12 +76,12 @@ class Trivia:  # pylint: disable=too-many-public-methods
         return T * np.power(const.p1000 / p, const.Rd_over_c_pd)
 
     @staticmethod
-    def unfrozen_and_saturated(water_mass, relative_humidity):
-        return water_mass > 0 and relative_humidity > 1
+    def unfrozen_and_saturated(signed_water_mass, relative_humidity):
+        return signed_water_mass > 0 and relative_humidity > 1
 
     @staticmethod
-    def frozen_and_above_freezing_point(const, water_mass, temperature):
-        return water_mass < 0 and temperature > const.T0
+    def frozen_and_above_freezing_point(const, signed_water_mass, temperature):
+        return signed_water_mass < 0 and temperature > const.T0
 
     @staticmethod
     def erfinv_approx(const, c):

{pysdm-2.101 → pysdm-2.102}/PySDM/products/size_spectral/cloud_water_content.py

@@ -38,15 +38,21 @@ class CloudWaterContent(MomentProduct):
 
         if self.ice:
             self._download_moment_to_buffer(
-                attr="water mass", rank=1, filter_range=(-np.inf, 0)
+                attr="water mass",
+                rank=1,
+                filter_range=(-np.inf, 0),
+                filter_attr="signed water mass",
             )
             mass = self.buffer.copy()
 
             self._download_moment_to_buffer(
-                attr="water mass", rank=0, filter_range=(-np.inf, 0)
+                attr="water mass",
+                rank=0,
+                filter_range=(-np.inf, 0),
+                filter_attr="signed water mass",
             )
             conc = self.buffer
-            cwc -= mass * conc / self.particulator.mesh.dv
+            cwc += mass * conc / self.particulator.mesh.dv
 
         if self.specific:
             self._download_to_buffer(self.particulator.environment["rhod"])

{pysdm-2.101 → pysdm-2.102}/PySDM/products/size_spectral/mean_radius.py

@@ -18,6 +18,10 @@ class MeanRadius(MomentProduct):
         self.radius_range = radius_range
         super().__init__(name=name, unit=unit)
 
+    def register(self, builder):
+        builder.request_attribute("volume")
+        super().register(builder)
+
     def _impl(self, **kwargs):
         self._download_moment_to_buffer(
             attr="volume",

{pysdm-2.101 → pysdm-2.102}/PySDM/products/size_spectral/water_mixing_ratio.py

@@ -12,25 +12,32 @@ from PySDM.products.impl import MomentProduct, register_product
 class WaterMixingRatio(MomentProduct):
     def __init__(self, radius_range=None, name=None, unit="dimensionless"):
         self.radius_range = radius_range or (0, np.inf)
-        self.volume_range = None
+        self.mass_range = None
         super().__init__(unit=unit, name=name)
 
     def register(self, builder):
         super().register(builder)
-        self.volume_range = self.formulae.trivia.volume(np.asarray(self.radius_range))
+        self.mass_range = self.formulae.particle_shape_and_density.radius_to_mass(
+            np.asarray(self.radius_range)
+        )
         self.radius_range = None
 
     def _impl(self, **kwargs):  # TODO #217
         self._download_moment_to_buffer(
-            attr="volume", rank=0, filter_range=self.volume_range, filter_attr="volume"
+            attr="water mass",
+            rank=0,
+            filter_range=self.mass_range,
+            filter_attr="water mass",
         )
         conc = self.buffer.copy()
 
         self._download_moment_to_buffer(
-            attr="volume", rank=1, filter_range=self.volume_range, filter_attr="volume"
+            attr="water mass",
+            rank=1,
+            filter_range=self.mass_range,
+            filter_attr="water mass",
         )
         result = self.buffer.copy()
-        result[:] *= self.formulae.constants.rho_w
         result[:] *= conc
         result[:] /= self.particulator.mesh.dv
 

{pysdm-2.101 → pysdm-2.102}/PySDM.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.101
+Version: 2.102
 Summary: Pythonic particle-based (super-droplet) warm-rain/aqueous-chemistry cloud microphysics package with box, parcel & 1D/2D prescribed-flow examples in Python, Julia and Matlab
 Home-page: https://github.com/open-atmos/PySDM
 Author: https://github.com/open-atmos/PySDM/graphs/contributors

{pysdm-2.101 → pysdm-2.102}/PySDM.egg-info/SOURCES.txt

@@ -891,6 +891,7 @@ tests/unit_tests/products/test_concentration_product.py
 tests/unit_tests/products/test_cooling_rate.py
 tests/unit_tests/products/test_effective_radii.py
 tests/unit_tests/products/test_impl.py
+tests/unit_tests/products/test_mixed_phase_moments.py
 tests/unit_tests/products/test_parcel_liquid_water_path.py
 tests/unit_tests/products/test_particle_size_product.py
 tests/unit_tests/products/test_particle_size_spectrum.py

{pysdm-2.101 → pysdm-2.102}/examples/PySDM_examples/Alpert_and_Knopf_2016/simulation.py

@@ -220,6 +220,7 @@ def simulation(
         environment=Box(dt=time_step, dv=volume),
     )
     builder.add_dynamic(Freezing(singular=False))
+    builder.request_attribute("volume")
 
     if hasattr(spectrum, "s_geom") and spectrum.s_geom == 1:
         _isa, _conc = np.full(n_sd, spectrum.m_mode), np.full(
@@ -230,7 +231,7 @@ def simulation(
     attributes = {
         "multiplicity": discretise_multiplicities(_conc * volume),
         "immersed surface area": _isa,
-        "volume": np.full(n_sd, droplet_volume),
+        "signed water mass": np.full(n_sd, droplet_volume * formulae.constants.rho_w),
     }
     np.testing.assert_almost_equal(attributes["multiplicity"], multiplicity)
     products = (