PySDM 3.0.0rc1__tar.gz → 3.0.0rc3__tar.gz

{pysdm-3.0.0rc1/pysdm.egg-info → pysdm-3.0.0rc3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pysdm
-Version: 3.0.0rc1
+Version: 3.0.0rc3
 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
 Author-email: "https://github.com/open-atmos/PySDM/graphs/contributors" <sylwester.arabas@agh.edu.pl>
 License-Expression: GPL-3.0-only

{pysdm-3.0.0rc1 → pysdm-3.0.0rc3}/PySDM/backends/impl_numba/methods/condensation_methods.py

@@ -21,7 +21,7 @@ _Counters = namedtuple(
 _Attributes = namedtuple(
     typename="_Attributes",
     field_names=(
-        "water_mass",
+        "signed_water_mass",
         "v_cr",
         "multiplicity",
         "vdry",
@@ -60,7 +60,7 @@ class CondensationMethods(BackendMethods):
             n_cell=kwargs["n_cell"],
             cell_start_arg=kwargs["cell_start_arg"].data,
             attributes=_Attributes(
-                water_mass=kwargs["water_mass"].data,
+                signed_water_mass=kwargs["signed_water_mass"].data,
                 v_cr=kwargs["v_cr"].data,
                 multiplicity=kwargs["multiplicity"].data,
                 vdry=kwargs["vdry"].data,
@@ -273,7 +273,7 @@ class CondensationMethods(BackendMethods):
         ):
             timestep /= n_substeps
             ml_old = calculate_ml_old(
-                attributes.water_mass, attributes.multiplicity, cell_idx
+                attributes.signed_water_mass, attributes.multiplicity, cell_idx
             )
             count_activating, count_deactivating, count_ripening = 0, 0, 0
             RH_max = 0
@@ -358,11 +358,11 @@ class CondensationMethods(BackendMethods):
     @staticmethod
     def make_calculate_ml_old(jit_flags):
         @numba.njit(**jit_flags)
-        def calculate_ml_old(water_mass, multiplicity, cell_idx):
+        def calculate_ml_old(signed_water_mass, multiplicity, cell_idx):
             result = 0
             for drop in cell_idx:
-                if water_mass[drop] > 0:
-                    result += multiplicity[drop] * water_mass[drop]
+                if signed_water_mass[drop] > 0:
+                    result += multiplicity[drop] * signed_water_mass[drop]
             return result
 
         return calculate_ml_old
@@ -429,12 +429,14 @@ class CondensationMethods(BackendMethods):
             lambdaK = formulae.diffusion_kinetics__lambdaK(T, p)
             lambdaD = formulae.diffusion_kinetics__lambdaD(DTp, T)
             for drop in cell_idx:
-                if attributes.water_mass[drop] <= 0:
+                if attributes.signed_water_mass[drop] <= 0:
                     continue
                 v_drop = formulae.particle_shape_and_density__mass_to_volume(
-                    attributes.water_mass[drop]
+                    attributes.signed_water_mass[drop]
+                )
+                x_old = formulae.diffusion_coordinate__x(
+                    attributes.signed_water_mass[drop]
                 )
-                x_old = formulae.diffusion_coordinate__x(attributes.water_mass[drop])
                 r_old = formulae.trivia__radius(v_drop)
                 x_insane = formulae.diffusion_coordinate__x(
                     formulae.particle_shape_and_density__volume_to_mass(
@@ -559,13 +561,16 @@ class CondensationMethods(BackendMethods):
                 )
                 result += attributes.multiplicity[drop] * mass_new
                 if not fake:
-                    if mass_new > mass_cr and mass_new > attributes.water_mass[drop]:
+                    if (
+                        mass_new > mass_cr
+                        and mass_new > attributes.signed_water_mass[drop]
+                    ):
                         n_activated_and_growing += attributes.multiplicity[drop]
-                    if mass_new > mass_cr > attributes.water_mass[drop]:
+                    if mass_new > mass_cr > attributes.signed_water_mass[drop]:
                         n_activating += attributes.multiplicity[drop]
-                    if mass_new < mass_cr < attributes.water_mass[drop]:
+                    if mass_new < mass_cr < attributes.signed_water_mass[drop]:
                         n_deactivating += attributes.multiplicity[drop]
-                    attributes.water_mass[drop] = mass_new
+                    attributes.signed_water_mass[drop] = mass_new
             n_ripening = n_activated_and_growing if n_deactivating > 0 else 0
             return result, success, n_activating, n_deactivating, n_ripening
 

pysdm-3.0.0rc3/PySDM/backends/impl_numba/methods/deposition_methods.py

@@ -0,0 +1,350 @@
+"""basic water vapor deposition on ice for CPU backend, for Howell factor see:
+[Howell 1949](https://doi.org/10.1175/1520-0469(1949)006%3C0134:TGOCDI%3E2.0.CO;2)
+"""
+
+from functools import cached_property
+import numba
+import numpy as np
+
+from PySDM.backends.impl_common.backend_methods import BackendMethods
+
+
+# TODO #1524
+# pylint: disable=too-many-arguments,too-many-locals,too-many-statements
+
+
+class DepositionMethods(BackendMethods):  # pylint:disable=too-few-public-methods
+    @cached_property
+    def _deposition(self):
+        assert self.formulae.particle_shape_and_density.supports_mixed_phase()
+
+        formulae = self.formulae_flattened
+        multiplier = 2
+        midpoint = True
+        rel_tol_rh = 1e-2
+        fuse = 16
+
+        @numba.njit(**{**self.default_jit_flags, **{"parallel": False}})
+        def calc_saturation_ratio_ice_temperature_and_pressure(
+            vapour_mixing_ratio, dry_air_potential_temperature, dry_air_density
+        ):
+            temperature = formulae.state_variable_triplet__T(
+                rhod=dry_air_density,
+                thd=dry_air_potential_temperature,
+            )
+            total_pressure = formulae.state_variable_triplet__p(
+                rhod=dry_air_density,
+                T=temperature,
+                water_vapour_mixing_ratio=vapour_mixing_ratio,
+            )
+            vapour_partial_pressure = formulae.state_variable_triplet__pv(
+                p=total_pressure,
+                water_vapour_mixing_ratio=vapour_mixing_ratio,
+            )
+            saturation_ratio_ice = (
+                vapour_partial_pressure
+                / formulae.saturation_vapour_pressure__pvs_ice(temperature)
+            )
+            return saturation_ratio_ice, temperature, total_pressure
+
+        @numba.njit(**{**self.default_jit_flags, **{"parallel": False}})
+        def mass_deposition_rate_per_droplet(
+            temperature: float,
+            rho_d: float,
+            signed_mass_old: float,
+            latent_heat_sub: float,
+            saturation_ratio_ice: float,
+            pressure: float,
+        ):
+            radius = formulae.particle_shape_and_density__mass_to_radius(
+                signed_mass_old
+            )
+            pvs_ice = formulae.saturation_vapour_pressure__pvs_ice(temperature)
+
+            capacity = formulae.diffusion_ice_capacity__capacity(abs(signed_mass_old))
+
+            mass_ventilation_factor = 1  # TODO #1655
+            heat_ventilation_factor = mass_ventilation_factor  # TODO #1588
+
+            Dv_const = formulae.diffusion_thermics__D(temperature, pressure)
+            lambdaD = formulae.diffusion_ice_kinetics__lambdaD(temperature, pressure)
+            diffusion_coefficient = formulae.diffusion_ice_kinetics__D(
+                Dv_const, radius, lambdaD, temperature
+            )
+
+            Ka_const = formulae.diffusion_thermics__K(temperature, pressure)
+            lambdaK = formulae.diffusion_ice_kinetics__lambdaK(temperature, pressure)
+            thermal_conductivity = formulae.diffusion_ice_kinetics__K(
+                Ka_const, radius, lambdaK, temperature, rho_d
+            )
+
+            Fk = formulae.drop_growth__Fk(
+                T=temperature,
+                K=thermal_conductivity * heat_ventilation_factor,
+                lv=latent_heat_sub,
+            )
+            Fd = formulae.drop_growth__Fd(
+                T=temperature,
+                D=diffusion_coefficient * mass_ventilation_factor,
+                pvs=pvs_ice,
+            )
+            howell_factor_x_diffcoef_x_rhovsice_x_icess = (
+                formulae.drop_growth__r_dr_dt(
+                    RH_eq=1,
+                    RH=saturation_ratio_ice,
+                    Fk=Fk,
+                    Fd=Fd,
+                )
+                * formulae.constants.rho_w
+            )
+
+            mass_deposition_rate = (
+                4 * np.pi * capacity * howell_factor_x_diffcoef_x_rhovsice_x_icess
+            )
+            if mass_deposition_rate > 1:
+                print(
+                    radius,
+                    Fk,
+                    Fd,
+                    mass_deposition_rate,
+                    howell_factor_x_diffcoef_x_rhovsice_x_icess,
+                    pvs_ice,
+                )
+                assert False
+            return mass_deposition_rate
+
+        @numba.njit(**{**self.default_jit_flags, **{"parallel": False}})
+        def _loop(
+            fake,
+            temperature,
+            rhod,
+            thd,
+            signed_water_mass,
+            saturation_ratio_ice,
+            total_pressure,
+            multiplicity,
+            sub_time_step,
+            mass_of_dry_air,
+        ):
+            latent_heat_sub = formulae.latent_heat_sublimation__ls(temperature)
+            delta_rv = 0
+            for i, ksi in enumerate(multiplicity):
+                if not formulae.trivia__unfrozen(signed_water_mass[i]):
+                    mass_deposition_rate = mass_deposition_rate_per_droplet(
+                        temperature=temperature,
+                        rho_d=rhod,
+                        signed_mass_old=signed_water_mass[i],
+                        latent_heat_sub=latent_heat_sub,
+                        saturation_ratio_ice=saturation_ratio_ice,
+                        pressure=total_pressure,
+                    )
+                    delta_rv += (
+                        -mass_deposition_rate * ksi * sub_time_step / mass_of_dry_air
+                    )
+                    if not fake:
+                        x_old = formulae.diffusion_coordinate__x(-signed_water_mass[i])
+                        dx_dt_old = formulae.diffusion_coordinate__dx_dt(
+                            -signed_water_mass[i], mass_deposition_rate
+                        )
+                        x_new = formulae.trivia__explicit_euler(
+                            x_old, sub_time_step, dx_dt_old
+                        )
+                        signed_water_mass[i] = -formulae.diffusion_coordinate__mass(
+                            x_new
+                        )
+                        if x_new > 1:
+                            print(x_old, dx_dt_old, x_new, signed_water_mass[i])
+                            assert False
+            delta_thd = (
+                formulae.state_variable_triplet__dthd_dt(
+                    rhod=rhod,
+                    thd=thd,
+                    T=temperature,
+                    d_water_vapour_mixing_ratio__dt=delta_rv / sub_time_step,
+                    lv=latent_heat_sub,
+                )
+                * sub_time_step
+            )
+            if delta_rv == 0:
+                assert delta_thd == 0
+            else:
+                assert (delta_rv < 0 < delta_thd) or (delta_rv > 0 > delta_thd)
+            return delta_rv, delta_thd
+
+        @numba.njit(**{**self.default_jit_flags, **{"parallel": False}})
+        def body(  # pylint: disable=too-many-arguments
+            *,
+            adaptive,
+            multiplicity,
+            signed_water_mass,
+            current_vapour_mixing_ratio,
+            current_dry_air_density,
+            current_dry_potential_temperature,
+            cell_volume,
+            time_step,
+            cell_id,
+            # to be modified
+            predicted_vapour_mixing_ratio,
+            predicted_dry_potential_temperature,
+            predicted_dry_air_density,
+        ):
+            """simplest adaptivity:
+            - global dt - no cell-wise logic (we don't have any test/example for it!)
+            - no mechanism to retain dt value over timesteps
+            - explicit Euler mass integration (vs. implicit in condensation)
+            """
+            # pylint: disable=too-many-locals
+            n_substeps = 1
+            cid = cell_id[0]  # TODO #1524: add support for multi-cell environments
+
+            rv_tendency = (
+                predicted_vapour_mixing_ratio[cid] - current_vapour_mixing_ratio[cid]
+            ) / time_step
+            thd_tendency = (
+                predicted_dry_potential_temperature[cid]
+                - current_dry_potential_temperature[cid]
+            ) / time_step
+            rhod_tendency = (
+                predicted_dry_air_density[cid] - current_dry_air_density[cid]
+            ) / time_step
+            dry_air_mass_mean = (
+                cell_volume
+                * (predicted_dry_air_density[cid] + current_dry_air_density[cid])
+                / 2
+            )
+
+            if adaptive:
+                n_substeps = 1 / multiplier
+                delta_rh_long = np.nan
+                for burnout in range(fuse + 1):
+                    if burnout == fuse:
+                        assert False
+                    sub_time_step = time_step / n_substeps
+                    rhod = (
+                        current_dry_air_density[cid]
+                        + rhod_tendency * (0.5 if midpoint else 1) * sub_time_step
+                    )
+                    rv = (
+                        current_vapour_mixing_ratio[cid]
+                        + rv_tendency * (0.5 if midpoint else 1) * sub_time_step
+                    )
+                    thd = (
+                        current_dry_potential_temperature[cid]
+                        + thd_tendency * (0.5 if midpoint else 1) * sub_time_step
+                    )
+
+                    saturation_ratio_ice, temperature, total_pressure = (
+                        calc_saturation_ratio_ice_temperature_and_pressure(
+                            vapour_mixing_ratio=rv,
+                            dry_air_potential_temperature=thd,
+                            dry_air_density=rhod,
+                        )
+                    )
+                    delta_rv, delta_thd = _loop(
+                        fake=True,
+                        temperature=temperature,
+                        rhod=rhod,
+                        thd=thd,
+                        signed_water_mass=signed_water_mass,
+                        saturation_ratio_ice=saturation_ratio_ice,
+                        total_pressure=total_pressure,
+                        multiplicity=multiplicity,
+                        sub_time_step=sub_time_step,
+                        mass_of_dry_air=dry_air_mass_mean,
+                    )
+                    delta_rh_short = (
+                        calc_saturation_ratio_ice_temperature_and_pressure(
+                            vapour_mixing_ratio=rv + delta_rv,
+                            dry_air_potential_temperature=thd + delta_thd,
+                            dry_air_density=rhod,
+                        )[0]
+                        - saturation_ratio_ice
+                    )
+                    if (
+                        n_substeps < 1
+                        or rv < -delta_rv
+                        or not formulae.trivia__within_tolerance(
+                            abs(delta_rh_long - multiplier * delta_rh_short),
+                            saturation_ratio_ice,
+                            rel_tol_rh,
+                        )
+                    ):
+                        delta_rh_long = delta_rh_short
+                        n_substeps *= multiplier
+                    else:
+                        break
+            sub_time_step = time_step / n_substeps
+
+            rv = current_vapour_mixing_ratio[cid]
+            thd = current_dry_potential_temperature[cid]
+            rhod = current_dry_air_density[cid]
+
+            assert n_substeps == int(n_substeps)
+            for _ in range(int(n_substeps)):
+                rv += sub_time_step * rv_tendency * (0.5 if midpoint else 1)
+                thd += sub_time_step * thd_tendency * (0.5 if midpoint else 1)
+                rhod += sub_time_step * rhod_tendency * (0.5 if midpoint else 1)
+
+                saturation_ratio_ice, temperature, total_pressure = (
+                    calc_saturation_ratio_ice_temperature_and_pressure(
+                        vapour_mixing_ratio=rv,
+                        dry_air_potential_temperature=thd,
+                        dry_air_density=rhod,
+                    )
+                )
+                delta_rv, delta_thd = _loop(
+                    fake=False,
+                    temperature=temperature,
+                    rhod=rhod,
+                    thd=thd,
+                    signed_water_mass=signed_water_mass,
+                    saturation_ratio_ice=saturation_ratio_ice,
+                    total_pressure=total_pressure,
+                    multiplicity=multiplicity,
+                    sub_time_step=sub_time_step,
+                    mass_of_dry_air=dry_air_mass_mean,
+                )
+                thd += delta_thd
+                rv += delta_rv
+                assert rv >= 0
+
+                if midpoint:
+                    thd += sub_time_step * thd_tendency / 2
+                    rv += sub_time_step * rv_tendency / 2
+                    rhod += sub_time_step * rhod_tendency / 2
+
+            predicted_dry_potential_temperature[cid] = thd
+            predicted_vapour_mixing_ratio[cid] = rv
+
+        return body
+
+    def deposition(  # pylint: disable=too-many-locals
+        self,
+        *,
+        adaptive,
+        multiplicity,
+        signed_water_mass,
+        current_vapour_mixing_ratio,
+        current_dry_air_density,
+        current_dry_potential_temperature,
+        cell_volume,
+        time_step,
+        cell_id,
+        predicted_vapour_mixing_ratio,
+        predicted_dry_potential_temperature,
+        predicted_dry_air_density,
+    ):
+        self._deposition(
+            adaptive=adaptive,
+            multiplicity=multiplicity.data,
+            signed_water_mass=signed_water_mass.data,
+            current_vapour_mixing_ratio=current_vapour_mixing_ratio.data,
+            current_dry_air_density=current_dry_air_density.data,
+            current_dry_potential_temperature=current_dry_potential_temperature.data,
+            cell_volume=cell_volume,
+            time_step=time_step,
+            cell_id=cell_id.data,
+            predicted_vapour_mixing_ratio=predicted_vapour_mixing_ratio.data,
+            predicted_dry_potential_temperature=predicted_dry_potential_temperature.data,
+            predicted_dry_air_density=predicted_dry_air_density.data,
+        )

{pysdm-3.0.0rc1 → pysdm-3.0.0rc3}/PySDM/backends/impl_numba/test_helpers/scipy_ode_condensation_solver.py

@@ -42,7 +42,7 @@ def _condensation(
         n_cell=particulator.mesh.n_cell,
         cell_start_arg=particulator.attributes.cell_start.data,
         attributes=_Attributes(
-            water_mass=particulator.attributes["water mass"].data,
+            signed_water_mass=particulator.attributes["signed water mass"].data,
             v_cr=None,
             multiplicity=particulator.attributes["multiplicity"].data,
             vdry=particulator.attributes["dry volume"].data,
@@ -242,7 +242,7 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
         y0 = np.empty(n_sd_in_cell + idx_x)
         y0[idx_thd] = thd
         y0[idx_x:] = jit_formulae.diffusion_coordinate__x(
-            attributes.water_mass[cell_idx]
+            attributes.signed_water_mass[cell_idx]
         )
         total_water_mixing_ratio = (
             water_vapour_mixing_ratio
@@ -288,12 +288,12 @@ def _make_solve(formulae):  # pylint: disable=too-many-statements,too-many-local
 
         m_new = 0
         for i in range(n_sd_in_cell):
-            attributes.water_mass[cell_idx[i]] = (
+            attributes.signed_water_mass[cell_idx[i]] = (
                 jit_formulae.diffusion_coordinate__mass(y1[idx_x + i])
             )
             m_new += (
                 attributes.multiplicity[cell_idx[i]]
-                * attributes.water_mass[cell_idx[i]]
+                * attributes.signed_water_mass[cell_idx[i]]
             )
 
         return (

{pysdm-3.0.0rc1 → pysdm-3.0.0rc3}/PySDM/backends/impl_thrust_rtc/methods/condensation_methods.py

@@ -40,10 +40,10 @@ class CondensationMethods(
     @cached_property
     def __calculate_m_l(self):
         return trtc.For(
-            param_names=("ml", "water_mass", "multiplicity", "cell_id"),
+            param_names=("ml", "signed_water_mass", "multiplicity", "cell_id"),
             name_iter="i",
             body="""
-            atomicAdd((real_type*) &ml[cell_id[i]], multiplicity[i] * water_mass[i]);
+            atomicAdd((real_type*) &ml[cell_id[i]], multiplicity[i] * signed_water_mass[i]);
             """.replace(
                 "real_type", self._get_c_type()
             ),
@@ -71,7 +71,7 @@ class CondensationMethods(
         const = phys.constants
         return trtc.For(
             param_names=(
-                "water_mass",
+                "signed_water_mass",
                 "vdry",
                 *CondensationMethods.keys,
                 "_kappa",
@@ -135,9 +135,9 @@ class CondensationMethods(
             auto _schmidt_number = schmidt_number[cell_id[i]];
 
             auto v_old = {phys.particle_shape_and_density.mass_to_volume.c_inline(
-                mass="water_mass[i]"
+                mass="signed_water_mass[i]"
             )};
-            auto x_old = {phys.diffusion_coordinate.x.c_inline(mass="water_mass[i]")};
+            auto x_old = {phys.diffusion_coordinate.x.c_inline(mass="signed_water_mass[i]")};
             auto r_old = {phys.trivia.radius.c_inline(volume="v_old")};
             auto m_insane = {phys.particle_shape_and_density.volume_to_mass.c_inline(volume="vdry[i] / 100")};
             auto x_insane = {phys.diffusion_coordinate.x.c_inline(mass="m_insane")};
@@ -187,7 +187,7 @@ class CondensationMethods(
                 )};
                 dm_dt_old = {phys.particle_shape_and_density.dm_dt.c_inline(r="r_old", r_dr_dt="r_dr_dt_old")};
                 dx_old = dt * {phys.diffusion_coordinate.dx_dt.c_inline(
-                    m="water_mass[i]", dm_dt="dm_dt_old"
+                    m="signed_water_mass[i]", dm_dt="dm_dt_old"
                 )};
             }}
             else {{
@@ -241,7 +241,7 @@ class CondensationMethods(
                     x_new = x_old;
                 }}
             }}
-            water_mass[i] = {phys.diffusion_coordinate.mass.c_inline(x="x_new")};
+            signed_water_mass[i] = {phys.diffusion_coordinate.mass.c_inline(x="x_new")};
         """.replace(
                 "real_type", self._get_c_type()
             ),
@@ -379,11 +379,11 @@ class CondensationMethods(
             ),
         )
 
-    def calculate_m_l(self, ml, water_mass, multiplicity, cell_id):
+    def calculate_m_l(self, ml, signed_water_mass, multiplicity, cell_id):
         ml[:] = 0
         self.__calculate_m_l.launch_n(
             n=len(multiplicity),
-            args=(ml.data, water_mass.data, multiplicity.data, cell_id.data),
+            args=(ml.data, signed_water_mass.data, multiplicity.data, cell_id.data),
         )
 
     # pylint: disable=unused-argument,too-many-locals
@@ -394,7 +394,7 @@ class CondensationMethods(
         solver,
         n_cell,
         cell_start_arg,
-        water_mass,
+        signed_water_mass,
         v_cr,
         multiplicity,
         vdry,
@@ -450,7 +450,7 @@ class CondensationMethods(
             ),
         )
         timestep /= n_substeps
-        self.calculate_m_l(self.ml_old, water_mass, multiplicity, cell_id)
+        self.calculate_m_l(self.ml_old, signed_water_mass, multiplicity, cell_id)
 
         for _ in range(n_substeps):
             self.__pre.launch_n(
@@ -472,7 +472,7 @@ class CondensationMethods(
             self.__update_drop_masses.launch_n(
                 n=len(multiplicity),
                 args=(
-                    water_mass.data,
+                    signed_water_mass.data,
                     vdry.data,
                     *self.vars_data.values(),
                     kappa.data,
@@ -485,7 +485,7 @@ class CondensationMethods(
                     reynolds_number.data,
                 ),
             )
-            self.calculate_m_l(self.ml_new, water_mass, multiplicity, cell_id)
+            self.calculate_m_l(self.ml_new, signed_water_mass, multiplicity, cell_id)
             self.__post.launch_n(
                 n=n_cell,
                 args=(

{pysdm-3.0.0rc1 → pysdm-3.0.0rc3}/PySDM/dynamics/vapour_deposition_on_ice.py

@@ -5,9 +5,10 @@ from PySDM.dynamics.impl import register_dynamic
 
 @register_dynamic()
 class VapourDepositionOnIce:
-    def __init__(self):
+    def __init__(self, adaptive: bool = True):
         """called by the user while building a particulator"""
         self.particulator = None
+        self.adaptive = adaptive
 
     def register(self, *, builder):
         """called by the builder"""
@@ -17,4 +18,4 @@ class VapourDepositionOnIce:
 
     def __call__(self):
         """called by the particulator during simulation"""
-        self.particulator.deposition()
+        self.particulator.deposition(adaptive=self.adaptive)

{pysdm-3.0.0rc1 → pysdm-3.0.0rc3}/PySDM/environments/kinematic_1d.py

@@ -8,7 +8,7 @@ import numpy as np
 from PySDM.environments.impl.moist import Moist
 
 from PySDM.impl import arakawa_c
-from PySDM.initialisation.equilibrate_wet_radii import equilibrate_wet_radii
+from PySDM.initialisation.hygroscopic_equilibrium import equilibrate_wet_radii
 from PySDM.environments.impl import register_environment
 
 

{pysdm-3.0.0rc1 → pysdm-3.0.0rc3}/PySDM/environments/kinematic_2d.py

@@ -7,7 +7,7 @@ import numpy as np
 
 from PySDM.environments.impl.moist import Moist
 from PySDM.impl.mesh import Mesh
-from PySDM.initialisation.equilibrate_wet_radii import (
+from PySDM.initialisation.hygroscopic_equilibrium import (
     default_rtol,
     equilibrate_wet_radii,
 )

{pysdm-3.0.0rc1 → pysdm-3.0.0rc3}/PySDM/environments/parcel.py

@@ -8,7 +8,7 @@ import numpy as np
 
 from PySDM.environments.impl.moist import Moist
 from PySDM.impl.mesh import Mesh
-from PySDM.initialisation.equilibrate_wet_radii import (
+from PySDM.initialisation.hygroscopic_equilibrium import (
     default_rtol,
     equilibrate_wet_radii,
 )

{pysdm-3.0.0rc1 → pysdm-3.0.0rc3}/PySDM/initialisation/__init__.py

@@ -5,7 +5,6 @@ wet radii equilibration
 
 from . import sampling, spectra
 from .discretise_multiplicities import discretise_multiplicities
-from .equilibrate_wet_radii import equilibrate_wet_radii
 from .init_fall_momenta import init_fall_momenta
 
 from . import aerosol_composition  # isort:skip