PySDM 2.42__tar.gz → 2.44__tar.gz

{PySDM-2.42 → PySDM-2.44}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: PySDM
-Version: 2.42
+Version: 2.44
 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.42 → PySDM-2.44}/PySDM/attributes/impl/mapper.py

@@ -51,8 +51,7 @@ attributes = {
     "volume": lambda _, __: Volume,
     "dry volume organic": lambda dynamics, formulae: (
         make_dummy_attribute_factory("dry volume organic")
-        if "Condensation" in dynamics
-        and formulae.surface_tension.__name__ == Constant.__name__
+        if formulae.surface_tension.__name__ == Constant.__name__
         else DryVolumeOrganic
     ),
     "dry volume": lambda dynamics, formulae: (
@@ -60,8 +59,7 @@ attributes = {
     ),
     "dry volume organic fraction": lambda dynamics, formulae: (
         make_dummy_attribute_factory("dry volume organic fraction")
-        if "Condensation" in dynamics
-        and formulae.surface_tension.__name__ == Constant.__name__
+        if formulae.surface_tension.__name__ == Constant.__name__
         else OrganicFraction
     ),
     "kappa times dry volume": lambda _, __: KappaTimesDryVolume,
@@ -124,6 +122,6 @@ attributes = {
 def get_class(name, dynamics, formulae):
     if name not in attributes:
         raise ValueError(
-            f"Unknown attribute name: {name}; valid names: {', '.join(attributes)}"
+            f"Unknown attribute name: {name}; valid names: {', '.join(sorted(attributes))}"
         )
     return attributes[name](dynamics, formulae)

{PySDM-2.42 → PySDM-2.44}/PySDM/backends/impl_numba/methods/terminal_velocity_methods.py

@@ -46,3 +46,23 @@ class TerminalVelocityMethods(BackendMethods):
         self.terminal_velocity_body(
             values=values, radius=radius, k1=k1, k2=k2, k3=k3, r1=r1, r2=r2
         )
+
+    @cached_property
+    def power_series_body(self):
+        @numba.njit(**{**conf.JIT_FLAGS, "fastmath": self.formulae.fastmath})
+        def power_series_body(*, values, radius, num_terms, prefactors, powers):
+            for i in numba.prange(len(values)):  # pylint: disable=not-an-iterable
+                values[i] = 0.0
+                for j in range(num_terms):
+                    values[i] = values[i] + prefactors[j] * radius[i] ** (powers[j] * 3)
+
+        return power_series_body
+
+    def power_series(self, *, values, radius, num_terms, prefactors, powers):
+        self.power_series_body(
+            values=values,
+            radius=radius,
+            num_terms=num_terms,
+            prefactors=prefactors,
+            powers=powers,
+        )

{PySDM-2.42 → PySDM-2.44}/PySDM/backends/impl_thrust_rtc/methods/terminal_velocity_methods.py

@@ -131,3 +131,27 @@ class TerminalVelocityMethods(ThrustRTCBackendMethods):
         self.__interpolation_body.launch_n(
             len(radius), (output.data, radius.data, factor_device, b.data, c.data)
         )
+
+    @cached_property
+    def __power_series_body(self):
+        # TODO #599 r<0
+        return trtc.For(
+            ("output", "radius", "num_terms", "prefactors", "powers"),
+            "i",
+            """
+            output[i] = 0.0
+            int kmax = num_terms
+            for (auto k = 0; k < kmax; k+=1) {
+                auto sumterm = prefactors[k] * pow(radius[i], 3*powers[k])
+                output[i] = output[i] + sumterm
+            """,
+        )
+
+    @nice_thrust(**NICE_THRUST_FLAGS)
+    def power_series(self, *, values, radius, num_terms, prefactors, powers):
+        prefactors = self._get_floating_point(prefactors)
+        powers = self._get_floating_point(powers)
+        num_terms = self._get_floating_point(num_terms)
+        self.__power_series_body.launch_n(
+            values.size(), (values, radius, num_terms, prefactors, powers)
+        )

{PySDM-2.42 → PySDM-2.44}/PySDM/dynamics/terminal_velocity/__init__.py

@@ -3,4 +3,5 @@ particle terminal velocity formulae
 """
 
 from PySDM.dynamics.terminal_velocity.gunn_and_kinzer import GunnKinzer1949
+from PySDM.dynamics.terminal_velocity.power_series import PowerSeries
 from PySDM.dynamics.terminal_velocity.rogers_and_yau import RogersYau

PySDM-2.44/PySDM/dynamics/terminal_velocity/power_series.py

@@ -0,0 +1,30 @@
+"""
+Power series expression
+"""
+
+import numpy as np
+
+from PySDM.physics import constants as const
+
+
+class PowerSeries:  # pylint: disable=too-few-public-methods
+    def __init__(self, particulator, *, prefactors=None, powers=None):
+        si = const.si
+        self.particulator = particulator
+        prefactors = prefactors or [2.0e-1 * si.m / si.s / np.sqrt(si.m)]
+        self.prefactors = np.array(prefactors)
+        powers = powers or [1 / 6]
+        self.powers = np.array(powers)
+        for i, p in enumerate(self.powers):
+            self.prefactors[i] *= (4 / 3 * const.PI) ** (p)
+            self.prefactors[i] /= (1 * si.um**3) ** (p)
+        assert len(self.prefactors) == len(self.powers)
+
+    def __call__(self, output, radius):
+        self.particulator.backend.power_series(
+            values=output.data,
+            radius=radius.data,
+            num_terms=len(self.powers),
+            prefactors=self.prefactors,
+            powers=self.powers,
+        )

{PySDM-2.42 → PySDM-2.44}/PySDM/environments/kinematic_1d.py

@@ -32,7 +32,13 @@ class Kinematic1D(Moist):
         return self.thd0
 
     def init_attributes(
-        self, *, spatial_discretisation, spectral_discretisation, kappa
+        self,
+        *,
+        spatial_discretisation,
+        spectral_discretisation,
+        kappa,
+        z_part=None,
+        collisions_only=False
     ):
         super().sync()
         self.notify()
@@ -43,6 +49,7 @@ class Kinematic1D(Moist):
                 backend=self.particulator.backend,
                 grid=self.mesh.grid,
                 n_sd=self.particulator.n_sd,
+                z_part=z_part,
             )
             (
                 attributes["cell id"],
@@ -50,24 +57,32 @@ class Kinematic1D(Moist):
                 attributes["position in cell"],
             ) = self.mesh.cellular_attributes(positions)
 
-            r_dry, n_per_kg = spectral_discretisation.sample(
-                backend=self.particulator.backend, n_sd=self.particulator.n_sd
-            )
-            attributes["dry volume"] = self.formulae.trivia.volume(radius=r_dry)
-            attributes["kappa times dry volume"] = attributes["dry volume"] * kappa
-            r_wet = equilibrate_wet_radii(
-                r_dry=r_dry,
-                environment=self,
-                cell_id=attributes["cell id"],
-                kappa_times_dry_volume=attributes["kappa times dry volume"],
-            )
+            if collisions_only:
+                v_wet, n_per_kg = spectral_discretisation.sample(
+                    backend=self.particulator.backend, n_sd=self.particulator.n_sd
+                )
+                # attributes["dry volume"] = v_wet
+                attributes["volume"] = v_wet
+                # attributes["kappa times dry volume"] = attributes["dry volume"] * kappa
+            else:
+                r_dry, n_per_kg = spectral_discretisation.sample(
+                    backend=self.particulator.backend, n_sd=self.particulator.n_sd
+                )
+                attributes["dry volume"] = self.formulae.trivia.volume(radius=r_dry)
+                attributes["kappa times dry volume"] = attributes["dry volume"] * kappa
+                r_wet = equilibrate_wet_radii(
+                    r_dry=r_dry,
+                    environment=self,
+                    cell_id=attributes["cell id"],
+                    kappa_times_dry_volume=attributes["kappa times dry volume"],
+                )
+                attributes["volume"] = self.formulae.trivia.volume(radius=r_wet)
 
             rhod = self["rhod"].to_ndarray()
             cell_id = attributes["cell id"]
             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)
 
         return attributes
 

{PySDM-2.42 → PySDM-2.44}/PySDM/formulae.py

@@ -19,7 +19,7 @@ from numba.core.errors import NumbaExperimentalFeatureWarning
 
 from PySDM import physics
 from PySDM.backends.impl_numba import conf
-from PySDM.dynamics.terminal_velocity import GunnKinzer1949, RogersYau
+from PySDM.dynamics.terminal_velocity import GunnKinzer1949, PowerSeries, RogersYau
 from PySDM.dynamics.terminal_velocity.gunn_and_kinzer import TpDependent
 
 
@@ -48,12 +48,16 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
         isotope_equilibrium_fractionation_factors: str = "Null",
         isotope_meteoric_water_line_excess: str = "Null",
         isotope_ratio_evolution: str = "Null",
+        optical_albedo: str = "Null",
+        optical_depth: str = "Null",
         particle_shape_and_density: str = "LiquidSpheres",
         terminal_velocity: str = "GunnKinzer1949",
         handle_all_breakups: bool = False,
     ):
         # initialisation of the fields below is just to silence pylint and to enable code hints
         # in PyCharm and alike, all these fields are later overwritten within this ctor
+        self.optical_albedo = optical_albedo
+        self.optical_depth = optical_depth
         self.condensation_coordinate = condensation_coordinate
         self.saturation_vapour_pressure = saturation_vapour_pressure
         self.hygroscopicity = hygroscopicity
@@ -120,6 +124,7 @@ class Formulae:  # pylint: disable=too-few-public-methods,too-many-instance-attr
             "GunnKinzer1949": GunnKinzer1949,
             "RogersYau": RogersYau,
             "TpDependent": TpDependent,
+            "PowerSeries": PowerSeries,
         }[terminal_velocity]
 
     def __str__(self):

{PySDM-2.42 → PySDM-2.44}/PySDM/initialisation/sampling/spatial_sampling.py

@@ -8,7 +8,7 @@ spatial sampling logic (i.e., physical x-y-z coordinates)
 
 class Pseudorandom:  # pylint: disable=too-few-public-methods
     @staticmethod
-    def sample(*, backend, grid, n_sd):
+    def sample(*, backend, grid, n_sd, z_part=None):
         dimension = len(grid)
         n_elements = dimension * n_sd
 
@@ -16,6 +16,15 @@ class Pseudorandom:  # pylint: disable=too-few-public-methods
         backend.Random(seed=backend.formulae.seed, size=n_elements)(storage)
         positions = storage.to_ndarray().reshape(dimension, n_sd)
 
-        for dim in range(dimension):
-            positions[dim, :] *= grid[dim]
+        if z_part is None:
+            for dim in range(dimension):
+                positions[dim, :] *= grid[dim]
+        else:
+            assert dimension == 1
+            iz_min = int(grid[0] * z_part[0])
+            iz_max = int(grid[0] * z_part[1])
+            for dim in range(dimension):
+                positions[dim, :] *= iz_max - iz_min
+                positions[dim, :] += iz_min
+
         return positions

{PySDM-2.42 → PySDM-2.44}/PySDM/physics/__init__.py

@@ -32,6 +32,8 @@ from . import (
     isotope_meteoric_water_line_excess,
     isotope_ratio_evolution,
     latent_heat,
+    optical_albedo,
+    optical_depth,
     particle_advection,
     particle_shape_and_density,
     saturation_vapour_pressure,

{PySDM-2.42 → PySDM-2.44}/PySDM/physics/constants.py

@@ -34,6 +34,7 @@ PI_4_3 = PI * 4 / 3
 LN_2 = np.log(2)
 ZERO_MASS = 0 * si.kg
 ZERO_VOLUME = 0 * si.m**3
+ONE = 1
 TWO = 2
 THREE = 3
 FOUR = 4

{PySDM-2.42 → PySDM-2.44}/PySDM/physics/constants_defaults.py

@@ -20,6 +20,7 @@ from .constants import (  # pylint: disable=unused-import
     PPM,
     T0,
     THREE,
+    ONE,
     TWO,
     TWO_THIRDS,
     M,
@@ -317,6 +318,9 @@ BARKAN_AND_LUZ_2007_EXCESS_18O_COEFF = 0.528
 CRAIG_1961_SLOPE_COEFF = 8
 CRAIG_1961_INTERCEPT_COEFF = 10 * PER_MILLE
 
+""" [Bohren 1987](https://doi.org/10.1119/1.15109) """
+asymmetry_g = 0.85  # forward scattering from cloud droplets
+
 
 def compute_derived_values(c: dict):
     c["eps"] = c["Mv"] / c["Md"]
@@ -325,6 +329,6 @@ def compute_derived_values(c: dict):
 
     c["Rd_over_c_pd"] = c["Rd"] / c["c_pd"]
 
-    c["nu_w"] = c["Mv"] / c["rho_w"]
+    c["water_molar_volume"] = c["Mv"] / c["rho_w"]
     c["rho_STP"] = c["p_STP"] / c["Rd"] / c["T_STP"]
     c["H_u"] = c["M"] / c["p_STP"]

PySDM-2.44/PySDM/physics/optical_albedo/__init__.py

@@ -0,0 +1,6 @@
+"""
+alternative formulations of cloud albedo
+"""
+
+from .bohren1987 import Bohren1987
+from .null import Null

PySDM-2.44/PySDM/physics/optical_albedo/bohren1987.py

@@ -0,0 +1,14 @@
+"""
+[Bohren 1987](https://doi.org/10.1119/1.15109) Eq. 14
+"""
+
+
+class Bohren1987:  # pylint: disable=too-few-public-methods
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def albedo(const, tau):
+        return ((const.ONE - const.asymmetry_g) * tau) / (
+            const.TWO + (const.ONE - const.asymmetry_g) * tau
+        )

PySDM-2.44/PySDM/physics/optical_albedo/null.py

@@ -0,0 +1,8 @@
+"""
+null (default) class
+"""
+
+
+class Null:  # pylint: disable=too-few-public-methods
+    def __init__(self, _):
+        pass

PySDM-2.44/PySDM/physics/optical_depth/__init__.py

@@ -0,0 +1,6 @@
+"""
+alternative formulations of optical depth
+"""
+
+from .stephens_1978 import Stephens1978
+from .null import Null

PySDM-2.44/PySDM/physics/optical_depth/null.py

@@ -0,0 +1,8 @@
+"""
+null (default) class
+"""
+
+
+class Null:  # pylint: disable=too-few-public-methods
+    def __init__(self, _):
+        pass

PySDM-2.44/PySDM/physics/optical_depth/stephens_1978.py

@@ -0,0 +1,13 @@
+"""
+[Stephens 1978](https://doi.org/10.1175/1520-0469(1978)035%3C2123:RPIEWC%3E2.0.CO;2)
+Eq. 7 for optical depth, where LWP is in g/m^2 and reff is in um.
+"""
+
+
+class Stephens1978:  # pylint: disable=too-few-public-methods
+    def __init__(self, _):
+        pass
+
+    @staticmethod
+    def tau(const, LWP, reff):
+        return (const.ONE_AND_A_HALF * LWP) / (const.rho_w * reff)

{PySDM-2.42 → PySDM-2.44}/PySDM/physics/surface_tension/compressed_film_ruehl.py

@@ -56,7 +56,9 @@ class CompressedFilmRuehl:  # pylint: disable=too-few-public-methods
         else:
             # C_bulk is the concentration of the organic in the bulk phase
             # Cb_iso = C_bulk / (1-f_surf)
-            Cb_iso = (f_org * v_dry / const.RUEHL_nu_org) / (v_wet / const.nu_w)
+            Cb_iso = (f_org * v_dry / const.RUEHL_nu_org) / (
+                v_wet / const.water_molar_volume
+            )
 
             # A is the area one molecule of organic occupies at the droplet surface
             # A_iso = A*f_surf (m^2)

{PySDM-2.42 → PySDM-2.44}/PySDM/physics/surface_tension/szyszkowski_langmuir.py

@@ -34,7 +34,9 @@ class SzyszkowskiLangmuir:  # pylint: disable=too-few-public-methods
         else:
             # C_bulk is the concentration of the organic in the bulk phase
             # Cb_iso = C_bulk / (1-f_surf)
-            Cb_iso = (f_org * v_dry / const.RUEHL_nu_org) / (v_wet / const.nu_w)
+            Cb_iso = (f_org * v_dry / const.RUEHL_nu_org) / (
+                v_wet / const.water_molar_volume
+            )
 
             # A is the area that one molecule of organic occupies at the droplet surface
             # A_iso = A*f_surf (m^2)

{PySDM-2.42 → PySDM-2.44}/PySDM/products/__init__.py

@@ -1,7 +1,5 @@
 """
-Simulation output products such as:
-`PySDM.products.size_spectral.particle_size_spectrum.ParticleSizeSpectrum`,
-...
+Simulation output products
 """
 
 from .ambient_thermodynamics import *
@@ -12,3 +10,5 @@ from .displacement import *
 from .freezing import *
 from .housekeeping import *
 from .size_spectral import *
+from .optical import *
+from .parcel import *

{PySDM-2.42 → PySDM-2.44}/PySDM/products/freezing/__init__.py

@@ -12,5 +12,4 @@ from .ice_nuclei_concentration import (
     IceNucleiConcentration,
     SpecificIceNucleiConcentration,
 )
-from .ice_water_content import IceWaterContent, SpecificIceWaterContent
 from .total_unfrozen_immersed_surface_area import TotalUnfrozenImmersedSurfaceArea

{PySDM-2.42 → PySDM-2.44}/PySDM/products/housekeeping/__init__.py

@@ -1,9 +1,8 @@
 """
-Housekeeping products: time, parcel displacement, super-particle counts, wall-time timers...
+Housekeeping products: time, super-particle count, wall-time timers...
 """
 
 from .dynamic_wall_time import DynamicWallTime
-from .parcel_displacement import ParcelDisplacement
 from .super_droplet_count_per_gridbox import SuperDropletCountPerGridbox
 from .time import Time
 from .timers import CPUTime, WallTime

PySDM-2.44/PySDM/products/optical/__init__.py

@@ -0,0 +1,4 @@
+""" cloud optical properties """
+
+from .cloud_optical_depth import CloudOpticalDepth
+from .cloud_albedo import CloudAlbedo

PySDM-2.44/PySDM/products/optical/cloud_albedo.py

@@ -0,0 +1,13 @@
+"""
+cloud albedo
+"""
+
+from PySDM.products.impl.product import Product
+
+
+class CloudAlbedo(Product):
+    def __init__(self, *, unit="dimensionless", name=None):
+        super().__init__(name=name, unit=unit)
+
+    def _impl(self, **kwargs):
+        return self.formulae.optical_albedo.albedo(kwargs["optical_depth"])

PySDM-2.44/PySDM/products/optical/cloud_optical_depth.py

@@ -0,0 +1,16 @@
+"""
+cloud optical depth
+"""
+
+from PySDM.products.impl.product import Product
+
+
+class CloudOpticalDepth(Product):
+    def __init__(self, *, unit="dimensionless", name=None):
+        super().__init__(name=name, unit=unit)
+
+    def _impl(self, **kwargs):
+        return self.formulae.optical_depth.tau(
+            kwargs["liquid_water_path"],
+            kwargs["effective_radius"],
+        )

PySDM-2.44/PySDM/products/parcel/__init__.py

@@ -0,0 +1,4 @@
+""" products specific to the parcel environment """
+
+from .cloud_water_path import ParcelLiquidWaterPath
+from .parcel_displacement import ParcelDisplacement

PySDM-2.44/PySDM/products/parcel/cloud_water_path.py

@@ -0,0 +1,55 @@
+"""
+cloud water path integrated over parcel displacement taking into account changes
+in parcel volume along the way
+"""
+
+from PySDM.environments.parcel import Parcel
+
+from PySDM.products.impl.activation_filtered_product import _ActivationFilteredProduct
+from PySDM.products.impl.moment_product import MomentProduct
+
+
+class ParcelLiquidWaterPath(MomentProduct, _ActivationFilteredProduct):
+    def __init__(
+        self,
+        count_unactivated: bool,
+        count_activated: bool,
+        name=None,
+        unit="kg/m^2",
+    ):
+        MomentProduct.__init__(self, unit=unit, name=name)
+        _ActivationFilteredProduct.__init__(
+            self, count_activated=count_activated, count_unactivated=count_unactivated
+        )
+        self.previous = {"z": 0.0, "cwc": 0.0}
+        self.cwp = 0.0
+
+    def register(self, builder):
+        if not isinstance(builder.particulator.environment, Parcel):
+            raise NotImplementedError()
+        _ActivationFilteredProduct.register(self, builder)
+        MomentProduct.register(self, builder)
+        self.particulator.observers.append(self)
+
+    def notify(self):
+        _ActivationFilteredProduct.impl(self, attr="water mass", rank=1)
+        avg_mass = self.buffer.copy()
+
+        _ActivationFilteredProduct.impl(self, attr="water mass", rank=0)
+        tot_numb = self.buffer.copy()
+
+        self._download_to_buffer(self.particulator.environment["z"])
+        current_z = self.buffer.copy()
+
+        cwc = avg_mass * tot_numb / self.particulator.mesh.dv
+        dz = current_z - self.previous["z"]
+        cwc_mean = (cwc + self.previous["cwc"]) / 2
+
+        if self.previous["cwc"] > 0:
+            self.cwp += cwc_mean * dz
+
+        self.previous["z"] = current_z
+        self.previous["cwc"] = cwc
+
+    def _impl(self, **kwargs):
+        return self.cwp

{PySDM-2.42 → PySDM-2.44}/PySDM/products/size_spectral/__init__.py

@@ -4,9 +4,11 @@ from .arbitrary_moment import (
     RadiusFirstMoment,
     RadiusSixthMoment,
     VolumeFirstMoment,
+    VolumeSecondMoment,
     ZerothMoment,
 )
 from .effective_radius import EffectiveRadius
+from .effective_radius_activated import ActivatedEffectiveRadius
 from .mean_radius import MeanRadius
 from .mean_radius_activated import ActivatedMeanRadius
 from .mean_volume_radius import MeanVolumeRadius
@@ -34,3 +36,11 @@ from .size_standard_deviation import (
 from .total_particle_concentration import TotalParticleConcentration
 from .total_particle_specific_concentration import TotalParticleSpecificConcentration
 from .water_mixing_ratio import WaterMixingRatio
+from .cloud_water_content import (
+    CloudWaterContent,
+    SpecificCloudWaterContent,
+    LiquidWaterContent,
+    SpecificLiquidWaterContent,
+    IceWaterContent,
+    SpecificIceWaterContent,
+)

{PySDM-2.42 → PySDM-2.44}/PySDM/products/size_spectral/arbitrary_moment.py

@@ -32,6 +32,10 @@ VolumeFirstMoment = make_arbitrary_moment_product(
     rank=1, attr="volume", attr_unit="m^3"
 )
 
+VolumeSecondMoment = make_arbitrary_moment_product(
+    rank=2, attr="volume", attr_unit="m^3"
+)
+
 RadiusSixthMoment = make_arbitrary_moment_product(rank=6, attr="radius", attr_unit="m")
 
 RadiusFirstMoment = make_arbitrary_moment_product(rank=1, attr="radius", attr_unit="m")

PySDM-2.44/PySDM/products/size_spectral/cloud_water_content.py

@@ -0,0 +1,78 @@
+"""
+cloud water content products, Specific means per mass of dry air
+
+CloudWaterContent is both liquid and ice
+LiquidWaterContent is just liquid
+IceWaterContent is just ice
+
+"""
+
+import numpy as np
+
+from PySDM.products.impl.moment_product import MomentProduct
+
+
+class CloudWaterContent(MomentProduct):
+    def __init__(
+        self, unit="kg/m^3", name=None, specific=False, liquid=True, ice=True
+    ):  # pylint: disable=too-many-arguments
+        super().__init__(unit=unit, name=name)
+        self.specific = specific
+        self.liquid = liquid
+        self.ice = ice
+
+    def _impl(self, **kwargs):
+        cwc = 0.0
+        if self.liquid:
+            self._download_moment_to_buffer(
+                attr="water mass", rank=1, filter_range=(0, np.inf)
+            )
+            mass = self.buffer.copy()
+
+            self._download_moment_to_buffer(
+                attr="water mass", rank=0, filter_range=(0, np.inf)
+            )
+            conc = self.buffer
+            cwc += mass * conc / self.particulator.mesh.dv
+
+        if self.ice:
+            self._download_moment_to_buffer(
+                attr="water mass", rank=1, filter_range=(-np.inf, 0)
+            )
+            mass = self.buffer.copy()
+
+            self._download_moment_to_buffer(
+                attr="water mass", rank=0, filter_range=(-np.inf, 0)
+            )
+            conc = self.buffer
+            cwc -= mass * conc / self.particulator.mesh.dv
+
+        if self.specific:
+            self._download_to_buffer(self.particulator.environment["rhod"])
+            cwc /= self.buffer
+        return cwc
+
+
+class SpecificCloudWaterContent(CloudWaterContent):
+    def __init__(self, unit="kg/kg", name=None):
+        super().__init__(unit=unit, name=name, specific=True, liquid=True, ice=True)
+
+
+class LiquidWaterContent(CloudWaterContent):
+    def __init__(self, unit="kg/m^3", name=None):
+        super().__init__(unit=unit, name=name, specific=False, liquid=True, ice=False)
+
+
+class SpecificLiquidWaterContent(CloudWaterContent):
+    def __init__(self, unit="kg/kg", name=None):
+        super().__init__(unit=unit, name=name, specific=True, liquid=True, ice=False)
+
+
+class IceWaterContent(CloudWaterContent):
+    def __init__(self, unit="kg/m^3", name=None):
+        super().__init__(unit=unit, name=name, specific=False, liquid=False, ice=True)
+
+
+class SpecificIceWaterContent(CloudWaterContent):
+    def __init__(self, unit="kg/kg", name=None):
+        super().__init__(unit=unit, name=name, specific=True, liquid=False, ice=True)