switching from "n" to "multiplicity" for attribute key (#1123)

Author: slayoo

.github/workflows/joss_paper.yml

@@ -22,9 +22,14 @@ jobs:
           python-version: 3.9
       - run: pip install -e .[tests]
       - run: pip install pytest-codeblocks pytest
+
       - run: python -c "import pytest_codeblocks; code=pytest_codeblocks.extract_from_file('paper/paperv1.md'); f=open('paperv1.py', 'w'); f.writelines(block.code for block in code); f.close()"
+      - run: echo "$(echo 'warnings.simplefilter("ignore", category=DeprecationWarning)'; cat paperv1.py)" > paperv1.py
+      - run: echo "$(echo 'import warnings'; cat paperv1.py)" > paperv1.py
       - run: python -We paperv1.py
+
       - run: python -c "import pytest_codeblocks; code=pytest_codeblocks.extract_from_file('paper/paper.md'); f=open('paper.py', 'w'); f.writelines(block.code for block in code); f.close()"
+      - run: echo "$(echo 'warnings.simplefilter("ignore", category=DeprecationWarning)'; cat paper.py)" > paper.py
       - run: echo "$(echo 'warnings.simplefilter("ignore", category=NumbaExperimentalFeatureWarning)'; cat paper.py)" > paper.py
       - run: echo "$(echo 'import warnings'; cat paper.py)" > paper.py
       - run: echo "$(echo 'from numba.core.errors import NumbaExperimentalFeatureWarning'; cat paper.py)" > paper.py

PySDM/attributes/impl/mapper.py

@@ -38,7 +38,7 @@
 from PySDM.physics.surface_tension import Constant
 
 attributes = {
-    "n": lambda _, __: Multiplicities,
+    "multiplicity": lambda _, __: Multiplicities,
     "volume": lambda _, __: Volume,
     "dry volume organic": lambda dynamics, formulae: (
         make_dummy_attribute_factory("dry volume organic")

PySDM/attributes/physics/multiplicities.py

@@ -12,4 +12,4 @@ class Multiplicities(BaseAttribute):
     MAX_VALUE = np.iinfo(TYPE).max
 
     def __init__(self, builder):
-        super().__init__(builder, name="n", dtype=Multiplicities.TYPE)
+        super().__init__(builder, name="multiplicity", dtype=Multiplicities.TYPE)

PySDM/backends/impl_numba/methods/collisions_methods.py

@@ -610,7 +610,7 @@ def scale_prob_for_adaptive_sdm_gamma(
         self,
         *,
         prob,
-        n,
+        multiplicity,
         cell_id,
         dt_left,
         dt,
@@ -621,9 +621,9 @@ def scale_prob_for_adaptive_sdm_gamma(
     ):
         return self.__scale_prob_for_adaptive_sdm_gamma_body(
             prob.data,
-            n.idx.data,
-            len(n),
-            n.data,
+            multiplicity.idx.data,
+            len(multiplicity),
+            multiplicity.data,
             cell_id.data,
             dt_left.data,
             dt,

PySDM/backends/impl_numba/methods/condensation_methods.py

@@ -23,7 +23,7 @@ def condensation(
         cell_start_arg,
         v,
         v_cr,
-        n,
+        multiplicity,
         vdry,
         idx,
         rhod,
@@ -52,7 +52,7 @@ def condensation(
             cell_start_arg=cell_start_arg.data,
             v=v.data,
             v_cr=v_cr.data,
-            n=n.data,
+            multiplicity=multiplicity.data,
             vdry=vdry.data,
             idx=idx.data,
             rhod=rhod.data,
@@ -86,7 +86,7 @@ def _condensation(
         cell_start_arg,
         v,
         v_cr,
-        n,
+        multiplicity,
         vdry,
         idx,
         rhod,
@@ -137,7 +137,7 @@ def _condensation(
                 ) = solver(
                     v,
                     v_cr,
-                    n,
+                    multiplicity,
                     vdry,
                     idx[cell_start:cell_end],
                     kappa,
@@ -254,7 +254,7 @@ def make_step_impl(
         def step_impl(  # pylint: disable=too-many-arguments,too-many-locals
             v,
             v_cr,
-            n,
+            multiplicity,
             vdry,
             cell_idx,
             kappa,
@@ -272,7 +272,7 @@ def step_impl(  # pylint: disable=too-many-arguments,too-many-locals
             fake,
         ):
             timestep /= n_substeps
-            ml_old = calculate_ml_old(v, n, cell_idx)
+            ml_old = calculate_ml_old(v, multiplicity, cell_idx)
             count_activating, count_deactivating, count_ripening = 0, 0, 0
             RH_max = 0
             success = True
@@ -304,7 +304,7 @@ def step_impl(  # pylint: disable=too-many-arguments,too-many-locals
                     RH,
                     v,
                     v_cr,
-                    n,
+                    multiplicity,
                     vdry,
                     cell_idx,
                     kappa,
@@ -398,7 +398,7 @@ def calculate_ml_new(  # pylint: disable=too-many-arguments,too-many-statements,
             RH,
             v,
             v_cr,
-            n,
+            multiplicity,
             vdry,
             cell_idx,
             kappa,
@@ -510,14 +510,14 @@ def calculate_ml_new(  # pylint: disable=too-many-arguments,too-many-statements,
                         x_new = x_old
 
                 v_new = volume_of_x(x_new)
-                result += n[drop] * v_new * const.rho_w
+                result += multiplicity[drop] * v_new * const.rho_w
                 if not fake:
                     if v_new > v_cr[drop] and v_new > v[drop]:
-                        n_activated_and_growing += n[drop]
+                        n_activated_and_growing += multiplicity[drop]
                     if v_new > v_cr[drop] > v[drop]:
-                        n_activating += n[drop]
+                        n_activating += multiplicity[drop]
                     if v_new < v_cr[drop] < v[drop]:
-                        n_deactivating += n[drop]
+                        n_deactivating += multiplicity[drop]
                     v[drop] = v_new
             n_ripening = n_activated_and_growing if n_deactivating > 0 else 0
             return result, success, n_activating, n_deactivating, n_ripening
@@ -658,7 +658,7 @@ def make_condensation_solver_impl(
         def solve(  # pylint: disable=too-many-arguments
             v,
             v_cr,
-            n,
+            multiplicity,
             vdry,
             cell_idx,
             kappa,
@@ -678,7 +678,7 @@ def solve(  # pylint: disable=too-many-arguments
             args = (
                 v,
                 v_cr,
-                n,
+                multiplicity,
                 vdry,
                 cell_idx,
                 kappa,

PySDM/backends/impl_numba/test_helpers/scipy_ode_condensation_solver.py

@@ -36,7 +36,7 @@ def _condensation(
         cell_start_arg=particulator.attributes.cell_start.data,
         v=particulator.attributes["volume"].data,
         v_cr=None,
-        n=particulator.attributes["n"].data,
+        multiplicity=particulator.attributes["multiplicity"].data,
         vdry=particulator.attributes["dry volume"].data,
         idx=particulator.attributes._ParticleAttributes__idx.data,
         rhod=particulator.environment["rhod"].data,
@@ -170,7 +170,7 @@ def _odesys(  # pylint: disable=too-many-arguments,too-many-locals
     def solve(  # pylint: disable=too-many-arguments,too-many-locals
         v,
         _,
-        n,
+        multiplicity,
         vdry,
         cell_idx,
         kappa,
@@ -191,12 +191,12 @@ def solve(  # pylint: disable=too-many-arguments,too-many-locals
         y0 = np.empty(n_sd_in_cell + idx_x)
         y0[idx_thd] = thd
         y0[idx_x:] = x(v[cell_idx])
-        qt = qv + _ql(n[cell_idx], y0[idx_x:], m_d_mean)
+        qt = qv + _ql(multiplicity[cell_idx], y0[idx_x:], m_d_mean)
         args = (
             kappa[cell_idx],
             f_org[cell_idx],
             vdry[cell_idx],
-            n[cell_idx],
+            multiplicity[cell_idx],
             dthd_dt,
             dqv_dt,
             drhod_dt,
@@ -228,7 +228,7 @@ def solve(  # pylint: disable=too-many-arguments,too-many-locals
         m_new = 0
         for i in range(n_sd_in_cell):
             v_new = volume(y1[idx_x + i])
-            m_new += n[cell_idx[i]] * v_new * rho_w
+            m_new += multiplicity[cell_idx[i]] * v_new * rho_w
             v[cell_idx[i]] = v_new
 
         return integ.success, qt - m_new / m_d_mean, y1[idx_thd], 1, 1, 1, 1, np.nan

PySDM/backends/impl_thrust_rtc/methods/collisions_methods.py

@@ -228,7 +228,7 @@ def __init__(self):
             param_names=(
                 "prob",
                 "idx",
-                "n",
+                "multiplicity",
                 "cell_id",
                 "dt",
                 "is_first_in_pair",
@@ -245,7 +245,7 @@ def __init__(self):
                 if (skip_pair) {{
                     return;
                 }}
-                auto prop = (int64_t)(n[j] / n[k]);
+                auto prop = (int64_t)(multiplicity[j] / multiplicity[k]);
                 auto dt_optimal = dt * prop / prob[i];
                 auto cid = cell_id[j];
                 static_assert(sizeof(dt_todo[0]) == sizeof(unsigned int), "");
@@ -680,7 +680,7 @@ def scale_prob_for_adaptive_sdm_gamma(
         self,
         *,
         prob,
-        n,
+        multiplicity,
         cell_id,
         dt_left,
         dt,
@@ -698,22 +698,22 @@ def scale_prob_for_adaptive_sdm_gamma(
             n=len(dt_left), args=(dt_todo, dt_left.data, d_dt_max)
         )
         self.__scale_prob_for_adaptive_sdm_gamma_body_2.launch_n(
-            n=len(n) // 2,
+            n=len(multiplicity) // 2,
             args=(
                 prob.data,
-                n.idx.data,
-                n.data,
+                multiplicity.idx.data,
+                multiplicity.data,
                 cell_id.data,
                 d_dt,
                 is_first_in_pair.indicator.data,
                 dt_todo,
             ),
         )
         self.__scale_prob_for_adaptive_sdm_gamma_body_3.launch_n(
-            n=len(n) // 2,
+            n=len(multiplicity) // 2,
             args=(
                 prob.data,
-                n.idx.data,
+                multiplicity.idx.data,
                 cell_id.data,
                 d_dt,
                 is_first_in_pair.indicator.data,

PySDM/backends/impl_thrust_rtc/methods/condensation_methods.py

@@ -36,10 +36,10 @@ def __init__(self):
         const = self.formulae.constants
 
         self.__calculate_m_l = trtc.For(
-            ("ml", "v", "n", "cell_id"),
+            ("ml", "v", "multiplicity", "cell_id"),
             "i",
             f"""
-            atomicAdd((real_type*) &ml[cell_id[i]], n[i] * v[i] * {const.rho_w});
+            atomicAdd((real_type*) &ml[cell_id[i]], multiplicity[i] * v[i] * {const.rho_w});
         """.replace(
                 "real_type", self._get_c_type()
             ),
@@ -312,9 +312,11 @@ def args(arg):
             ),
         )
 
-    def calculate_m_l(self, ml, v, n, cell_id):
+    def calculate_m_l(self, ml, v, multiplicity, cell_id):
         ml[:] = 0
-        self.__calculate_m_l.launch_n(len(n), (ml.data, v.data, n.data, cell_id.data))
+        self.__calculate_m_l.launch_n(
+            len(multiplicity), (ml.data, v.data, multiplicity.data, cell_id.data)
+        )
 
     # pylint: disable=unused-argument,too-many-locals
     @nice_thrust(**NICE_THRUST_FLAGS)
@@ -326,7 +328,7 @@ def condensation(
         cell_start_arg,
         v,
         v_cr,
-        n,
+        multiplicity,
         vdry,
         idx,
         rhod,
@@ -377,7 +379,7 @@ def condensation(
             ),
         )
         timestep /= n_substeps
-        self.calculate_m_l(self.ml_old, v, n, cell_id)
+        self.calculate_m_l(self.ml_old, v, multiplicity, cell_id)
 
         for _ in range(n_substeps):
             self.__pre.launch_n(
@@ -395,7 +397,7 @@ def condensation(
                 ),
             )
             self.__update_volume.launch_n(
-                len(n),
+                len(multiplicity),
                 (
                     v.data,
                     vdry.data,
@@ -409,7 +411,7 @@ def condensation(
                     cell_id.data,
                 ),
             )
-            self.calculate_m_l(self.ml_new, v, n, cell_id)
+            self.calculate_m_l(self.ml_new, v, multiplicity, cell_id)
             self.__post.launch_n(
                 n_cell,
                 (

PySDM/backends/impl_thrust_rtc/methods/displacement_methods.py

@@ -69,15 +69,15 @@ def __init__(self):
                 "cell_origin",
                 "position_in_cell",
                 "volume",
-                "n",
+                "multiplicity",
                 "rainfall",
             ),
             "i",
             """
             auto origin = cell_origin[n_sd * (n_dims-1) + idx[i]];
             auto pic = position_in_cell[n_sd * (n_dims-1) + idx[i]];
             if (origin + pic < 0) {
-                atomicAdd((real_type*) &rainfall[0], n[idx[i]] * volume[idx[i]]);
+                atomicAdd((real_type*) &rainfall[0], multiplicity[idx[i]] * volume[idx[i]]);
                 idx[i] = n_sd;
                 healthy[0] = 0;
             }
@@ -129,7 +129,7 @@ def flag_precipitated(  # pylint: disable=unused-argument
         trtc.Fill(rainfall, self._get_floating_point(0))
         self.__flag_precipitated_body.launch_n(
             length,
-            [
+            (
                 idx.data,
                 n_sd,
                 n_dims,
@@ -139,7 +139,7 @@ def flag_precipitated(  # pylint: disable=unused-argument
                 volume.data,
                 multiplicity.data,
                 rainfall,
-            ],
+            ),
         )
         return rainfall.to_host()[0]