Merge pull request #830 from slayoo/issue_682

addressing/disabling pylint too-many-arguments warnings

Author: slayoo

.github/workflows/pylint.yml

@@ -27,4 +27,4 @@ jobs:
     - name: Analysing the code with pylint
       run: |
         # TODO #682
-        pylint --disable=fixme,invalid-name,missing-function-docstring,missing-class-docstring,too-many-arguments,too-many-locals,too-many-instance-attributes,too-few-public-methods,protected-access,too-many-statements,duplicate-code,C0330,C0326 $(git ls-files '*.py')
+        pylint --disable=fixme,invalid-name,missing-function-docstring,missing-class-docstring,too-many-locals,too-many-instance-attributes,too-few-public-methods,protected-access,too-many-statements,duplicate-code,C0330,C0326 $(git ls-files '*.py')

PySDM/attributes/chemistry/acidity.py

@@ -24,17 +24,17 @@ def recalculate(self):
         dynamic = self.particulator.dynamics["AqueousChemistry"]
 
         self.particulator.backend.equilibrate_H(
-            dynamic.equilibrium_consts,
-            self.cell_id.get(),
-            _conc(
+            equilibrium_consts=dynamic.equilibrium_consts,
+            cell_id=self.cell_id.get(),
+            conc=_conc(
                 N_mIII=self.conc["N_mIII"].get(),
                 N_V=self.conc["N_V"].get(),
                 C_IV=self.conc["C_IV"].get(),
                 S_IV=self.conc["S_IV"].get(),
                 S_VI=self.conc["S_VI"].get(),
             ),
-            dynamic.do_chemistry_flag,
-            self.data,
+            do_chemistry_flag=dynamic.do_chemistry_flag,
+            pH=self.data,
             H_min=dynamic.pH_H_min,
             H_max=dynamic.pH_H_max,
             ionic_strength_threshold=dynamic.ionic_strength_threshold,

PySDM/attributes/physics/critical_volume.py

@@ -18,7 +18,7 @@ def __init__(self, builder):
 
     def recalculate(self):
         self.particulator.backend.critical_volume(
-            self.data,
+            v_cr=self.data,
             kappa=self.kappa.get(),
             f_org=self.f_org.get(),
             v_dry=self.v_dry.get(),

PySDM/backends/impl_numba/methods/chemistry_methods.py

@@ -59,7 +59,7 @@ def dissolution(
         dv,
         system_type,
         droplet_volume,
-        multiplicity
+        multiplicity,
     ):
         for thread_id in numba.prange(n_threads):  # pylint: disable=not-an-iterable
             for i in range(thread_id, n_cell, n_threads):
@@ -108,6 +108,7 @@ def dissolution(
     @staticmethod
     @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
     def dissolution_body(
+        *,
         super_droplet_ids,
         mole_amounts,
         env_mixing_ratio,
@@ -156,6 +157,7 @@ def dissolution_body(
 
     def oxidation(
         self,
+        *,
         n_sd,
         cell_ids,
         do_chemistry_flag,
@@ -176,31 +178,32 @@ def oxidation(
         moles_S_VI,
     ):
         ChemistryMethods.oxidation_body(
-            n_sd,
-            cell_ids.data,
-            do_chemistry_flag.data,
-            self.formulae.trivia.explicit_euler,
-            self.formulae.trivia.pH2H,
-            k0.data,
-            k1.data,
-            k2.data,
-            k3.data,
-            K_SO2.data,
-            K_HSO3.data,
-            timestep,
-            droplet_volume.data,
-            pH.data,
-            dissociation_factor_SO2.data,
+            n_sd=n_sd,
+            cell_ids=cell_ids.data,
+            do_chemistry_flag=do_chemistry_flag.data,
+            explicit_euler=self.formulae.trivia.explicit_euler,
+            pH2H=self.formulae.trivia.pH2H,
+            k0=k0.data,
+            k1=k1.data,
+            k2=k2.data,
+            k3=k3.data,
+            K_SO2=K_SO2.data,
+            K_HSO3=K_HSO3.data,
+            timestep=timestep,
+            droplet_volume=droplet_volume.data,
+            pH=pH.data,
+            dissociation_factor_SO2=dissociation_factor_SO2.data,
             # output
-            moles_O3.data,
-            moles_H2O2.data,
-            moles_S_IV.data,
-            moles_S_VI.data,
+            moles_O3=moles_O3.data,
+            moles_H2O2=moles_H2O2.data,
+            moles_S_IV=moles_S_IV.data,
+            moles_S_VI=moles_S_VI.data,
         )
 
     @staticmethod
     @numba.njit(**conf.JIT_FLAGS)
     def oxidation_body(
+        *,
         n_sd,
         cell_ids,
         do_chemistry_flag,
@@ -303,6 +306,7 @@ def chem_recalculate_cell_data(
 
     def equilibrate_H(
         self,
+        *,
         equilibrium_consts,
         cell_id,
         conc,
@@ -346,7 +350,7 @@ def equilibrate_H(
 
     @staticmethod
     @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False, "cache": False}})
-    def equilibrate_H_body(
+    def equilibrate_H_body(  # pylint: disable=too-many-arguments
         within_tolerance,
         pH2H,
         H2pH,

PySDM/backends/impl_numba/methods/collisions_methods.py

@@ -31,7 +31,9 @@ def flag_zero_multiplicity(j, k, multiplicity, healthy):
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def coalesce(i, j, k, cid, multiplicity, gamma, attributes, coalescence_rate):
+def coalesce(  # pylint: disable=too-many-arguments
+    i, j, k, cid, multiplicity, gamma, attributes, coalescence_rate
+):
     atomic_add(coalescence_rate, cid, gamma[i] * multiplicity[k])
     new_n = multiplicity[j] - gamma[i] * multiplicity[k]
     if new_n > 0:
@@ -47,7 +49,7 @@ def coalesce(i, j, k, cid, multiplicity, gamma, attributes, coalescence_rate):
 
 
 @numba.njit(**{**conf.JIT_FLAGS, **{"parallel": False}})
-def break_up(
+def break_up(  # pylint: disable=too-many-arguments
     i,
     j,
     k,
@@ -172,9 +174,9 @@ def __adaptive_sdm_gamma_body(
             if dt_todo[cid] > 0:
                 stats_n_substep[cid] += 1
 
-    # pylint: disable=too-many-arguments
     def adaptive_sdm_gamma(
         self,
+        *,
         gamma,
         n,
         cell_id,
@@ -210,6 +212,7 @@ def cell_id(self, cell_id, cell_origin, strides):
     @staticmethod
     @numba.njit(**conf.JIT_FLAGS)
     def __collision_coalescence_body(
+        *,
         multiplicity,
         idx,
         length,
@@ -233,6 +236,7 @@ def __collision_coalescence_body(
 
     def collision_coalescence(
         self,
+        *,
         multiplicity,
         idx,
         attributes,
@@ -243,20 +247,21 @@ def collision_coalescence(
         is_first_in_pair,
     ):
         self.__collision_coalescence_body(
-            multiplicity.data,
-            idx.data,
-            len(idx),
-            attributes.data,
-            gamma.data,
-            healthy.data,
-            cell_id.data,
-            coalescence_rate.data,
-            is_first_in_pair.indicator.data,
+            multiplicity=multiplicity.data,
+            idx=idx.data,
+            length=len(idx),
+            attributes=attributes.data,
+            gamma=gamma.data,
+            healthy=healthy.data,
+            cell_id=cell_id.data,
+            coalescence_rate=coalescence_rate.data,
+            is_first_in_pair=is_first_in_pair.indicator.data,
         )
 
     @staticmethod
     @numba.njit(**conf.JIT_FLAGS)
     def __collision_coalescence_breakup_body(
+        *,
         multiplicity,
         idx,
         length,
@@ -312,6 +317,7 @@ def __collision_coalescence_breakup_body(
 
     def collision_coalescence_breakup(
         self,
+        *,
         multiplicity,
         idx,
         attributes,
@@ -329,22 +335,22 @@ def collision_coalescence_breakup(
     ):
         max_multiplicity = np.iinfo(multiplicity.data.dtype).max // 2e5
         self.__collision_coalescence_breakup_body(
-            multiplicity.data,
-            idx.data,
-            len(idx),
-            attributes.data,
-            gamma.data,
-            rand.data,
-            Ec.data,
-            Eb.data,
-            n_fragment.data,
-            healthy.data,
-            cell_id.data,
-            coalescence_rate.data,
-            breakup_rate.data,
-            breakup_rate_deficit.data,
-            is_first_in_pair.indicator.data,
-            max_multiplicity,
+            multiplicity=multiplicity.data,
+            idx=idx.data,
+            length=len(idx),
+            attributes=attributes.data,
+            gamma=gamma.data,
+            rand=rand.data,
+            Ec=Ec.data,
+            Eb=Eb.data,
+            n_fragment=n_fragment.data,
+            healthy=healthy.data,
+            cell_id=cell_id.data,
+            coalescence_rate=coalescence_rate.data,
+            breakup_rate=breakup_rate.data,
+            breakup_rate_deficit=breakup_rate_deficit.data,
+            is_first_in_pair=is_first_in_pair.indicator.data,
+            max_multiplicity=max_multiplicity,
         )
 
     @staticmethod
@@ -365,7 +371,7 @@ def slams_fragmentation(self, n_fragment, probs, rand):
     @staticmethod
     @numba.njit(**{**conf.JIT_FLAGS})
     def __exp_fragmentation_body(
-        n_fragment, scale, frag_size, v_max, x_plus_y, rand, vmin, nfmax
+        *, n_fragment, scale, frag_size, v_max, x_plus_y, rand, vmin, nfmax
     ):
         """
         Exponential PDF
@@ -383,23 +389,23 @@ def __exp_fragmentation_body(
                 n_fragment[i] = min(n_fragment[i], nfmax)
 
     def exp_fragmentation(
-        self, n_fragment, scale, frag_size, v_max, x_plus_y, rand, vmin, nfmax
+        self, *, n_fragment, scale, frag_size, v_max, x_plus_y, rand, vmin, nfmax
     ):
         self.__exp_fragmentation_body(
-            n_fragment.data,
-            scale,
-            frag_size.data,
-            v_max.data,
-            x_plus_y.data,
-            rand.data,
-            vmin,
-            nfmax,
+            n_fragment=n_fragment.data,
+            scale=scale,
+            frag_size=frag_size.data,
+            v_max=v_max.data,
+            x_plus_y=x_plus_y.data,
+            rand=rand.data,
+            vmin=vmin,
+            nfmax=nfmax,
         )
 
     @staticmethod
     @numba.njit(**{**conf.JIT_FLAGS})
     def __feingold1988_fragmentation_body(
-        n_fragment, scale, frag_size, v_max, x_plus_y, rand, fragtol, vmin, nfmax
+        *, n_fragment, scale, frag_size, v_max, x_plus_y, rand, fragtol, vmin, nfmax
     ):
         """
         Scaled exponential PDF
@@ -417,23 +423,33 @@ def __feingold1988_fragmentation_body(
                 n_fragment[i] = min(n_fragment[i], nfmax)
 
     def feingold1988_fragmentation(
-        self, n_fragment, scale, frag_size, v_max, x_plus_y, rand, fragtol, vmin, nfmax
+        self,
+        *,
+        n_fragment,
+        scale,
+        frag_size,
+        v_max,
+        x_plus_y,
+        rand,
+        fragtol,
+        vmin,
+        nfmax,
     ):
         self.__feingold1988_fragmentation_body(
-            n_fragment.data,
-            scale,
-            frag_size.data,
-            v_max.data,
-            x_plus_y.data,
-            rand.data,
-            fragtol,
-            vmin,
-            nfmax,
+            n_fragment=n_fragment.data,
+            scale=scale,
+            frag_size=frag_size.data,
+            v_max=v_max.data,
+            x_plus_y=x_plus_y.data,
+            rand=rand.data,
+            fragtol=fragtol,
+            vmin=vmin,
+            nfmax=nfmax,
         )
 
     @staticmethod
     @numba.njit(**{**conf.JIT_FLAGS})
-    def __gauss_fragmentation_body(n_fragment, mu, scale, frag_size, r_max, rand):
+    def __gauss_fragmentation_body(*, n_fragment, mu, scale, frag_size, r_max, rand):
         """
         Gaussian PDF
         CDF = erf(x); approximate as erf(x) ~ tanh(ax) with a = 2/sqrt(pi) as in Vedder 1987
@@ -447,9 +463,14 @@ def __gauss_fragmentation_body(n_fragment, mu, scale, frag_size, r_max, rand):
             else:
                 n_fragment[i] = r_max[i] / frag_size[i]
 
-    def gauss_fragmentation(self, n_fragment, mu, scale, frag_size, r_max, rand):
+    def gauss_fragmentation(self, *, n_fragment, mu, scale, frag_size, r_max, rand):
         self.__gauss_fragmentation_body(
-            n_fragment.data, mu, scale, frag_size.data, r_max.data, rand.data
+            n_fragment=n_fragment.data,
+            mu=mu,
+            scale=scale,
+            frag_size=frag_size.data,
+            r_max=r_max.data,
+            rand=rand.data,
         )
 
     @staticmethod
@@ -503,9 +524,9 @@ def __compute_gamma_body(
             )
             gamma[i] = g
 
-    # pylint: disable=too-many-arguments
     def compute_gamma(
         self,
+        *,
         gamma,
         rand,
         multiplicity,