More linting...

Author: Sfonxu

examples/PyMPDATA_examples/Jarecka_et_al_2015/formulae.py

@@ -7,6 +7,8 @@
 import numpy as np
 from scipy.integrate import odeint
 
+from PyMPDATA.impl.enumerations import ARG_DATA, ARG_FOCUS, MAX_DIM_NUM
+
 
 def amplitude(x, y, lx, ly):
     A = 1 / lx / ly
@@ -34,3 +36,95 @@ def d2_el_lamb_lamb_t_evol(times, lamb_x0, lamb_y0):
     result, info = odeint(deriv, yinit, times, full_output=True)
     assert info["message"] == "Integration successful."
     return result
+
+
+def make_rhs_indexers(ats, grid_step, time_step, options):
+    @numba.njit(**options.jit_flags)
+    def rhs(m, _0, h, _1, _2, _3):
+        retval = (
+            m
+            - ((ats(*h, +1) - ats(*h, -1)) / 2) / 2 * ats(*h, 0) * time_step / grid_step
+        )
+        return retval
+
+    return rhs
+
+
+def make_rhs(grid_step, time_step, axis, options, traversals):
+    indexers = traversals.indexers[traversals.n_dims]
+    apply_scalar = traversals.apply_scalar(loop=False)
+
+    formulae_rhs = tuple(
+        (
+            make_rhs_indexers(
+                ats=indexers.ats[axis],
+                grid_step=grid_step[axis],
+                time_step=time_step,
+                options=options,
+            ),
+            None,
+            None,
+        )
+    )
+
+    @numba.njit(**options.jit_flags)
+    def apply(traversals_data, momentum, h):
+        null_scalarfield, null_scalarfield_bc = traversals_data.null_scalar_field
+        null_vectorfield, null_vectorfield_bc = traversals_data.null_vector_field
+        return apply_scalar(
+            *formulae_rhs,
+            *momentum.field,
+            *null_vectorfield,
+            null_vectorfield_bc,
+            *h.field,
+            h.bc,
+            *null_scalarfield,
+            null_scalarfield_bc,
+            *null_scalarfield,
+            null_scalarfield_bc,
+            *null_scalarfield,
+            null_scalarfield_bc,
+            traversals_data.buffer
+        )
+
+    return apply
+
+
+def make_interpolate_indexers(ati, options):
+    @numba.njit(**options.jit_flags)
+    def interpolate(momentum_x, _, momentum_y):
+        momenta = (momentum_x[ARG_FOCUS], (momentum_x[ARG_DATA], momentum_y[ARG_DATA]))
+        return ati(*momenta, 0.5)
+
+    return interpolate
+
+
+def make_interpolate(options, traversals):
+    indexers = traversals.indexers[traversals.n_dims]
+    apply_vector = traversals.apply_vector()
+
+    formulae_interpolate = tuple(
+        (
+            make_interpolate_indexers(ati=indexers.ati[i], options=options)
+            if indexers.ati[i] is not None
+            else None
+        )
+        for i in range(MAX_DIM_NUM)
+    )
+
+    @numba.njit(**options.jit_flags)
+    def apply(traversals_data, momentum_x, momentum_y, advector):
+        null_vectorfield, null_vectorfield_bc = traversals_data.null_vector_field
+        return apply_vector(
+            *formulae_interpolate,
+            *advector.field,
+            *momentum_x.field,
+            momentum_x.bc,
+            *null_vectorfield,
+            null_vectorfield_bc,
+            *momentum_y.field,
+            momentum_y.bc,
+            traversals_data.buffer
+        )
+
+    return apply

examples/PyMPDATA_examples/Jarecka_et_al_2015/simulation.py

@@ -4,112 +4,19 @@
 
 from PyMPDATA import ScalarField, Solver, Stepper, VectorField
 from PyMPDATA.boundary_conditions import Constant
-from PyMPDATA.impl.enumerations import ARG_DATA, ARG_FOCUS, INNER, MAX_DIM_NUM, OUTER
+from PyMPDATA.impl.enumerations import INNER, OUTER
 from PyMPDATA.impl.formulae_divide import make_divide_or_zero
 
 
-def make_rhs_indexers(ats, grid_step, time_step, options):
-    @numba.njit(**options.jit_flags)
-    def rhs(m, _0, h, _1, _2, _3):
-        retval = (
-            m
-            - ((ats(*h, +1) - ats(*h, -1)) / 2) / 2 * ats(*h, 0) * time_step / grid_step
-        )
-        return retval
-
-    return rhs
-
-
-def make_rhs(grid_step, time_step, axis, options, traversals):
-    indexers = traversals.indexers[traversals.n_dims]
-    apply_scalar = traversals.apply_scalar(loop=False)
-
-    formulae_rhs = tuple(
-        (
-            make_rhs_indexers(
-                ats=indexers.ats[axis],
-                grid_step=grid_step[axis],
-                time_step=time_step,
-                options=options,
-            ),
-            None,
-            None,
-        )
-    )
-
-    @numba.njit(**options.jit_flags)
-    def apply(traversals_data, momentum, h):
-        null_scalarfield, null_scalarfield_bc = traversals_data.null_scalar_field
-        null_vectorfield, null_vectorfield_bc = traversals_data.null_vector_field
-        return apply_scalar(
-            *formulae_rhs,
-            *momentum.field,
-            *null_vectorfield,
-            null_vectorfield_bc,
-            *h.field,
-            h.bc,
-            *null_scalarfield,
-            null_scalarfield_bc,
-            *null_scalarfield,
-            null_scalarfield_bc,
-            *null_scalarfield,
-            null_scalarfield_bc,
-            traversals_data.buffer
-        )
-
-    return apply
-
-
-def make_interpolate_indexers(ati, options):
-    @numba.njit(**options.jit_flags)
-    def interpolate(momentum_x, _, momentum_y):
-        momenta = (momentum_x[ARG_FOCUS], (momentum_x[ARG_DATA], momentum_y[ARG_DATA]))
-        return ati(*momenta, 0.5)
-
-    return interpolate
-
-
-def make_interpolate(options, traversals):
-    indexers = traversals.indexers[traversals.n_dims]
-    apply_vector = traversals.apply_vector()
-
-    formulae_interpolate = tuple(
-        (
-            make_interpolate_indexers(ati=indexers.ati[i], options=options)
-            if indexers.ati[i] is not None
-            else None
-        )
-        for i in range(MAX_DIM_NUM)
-    )
-
-    @numba.njit(**options.jit_flags)
-    def apply(traversals_data, momentum_x, momentum_y, advector):
-        null_scalarfield, null_scalarfield_bc = traversals_data.null_scalar_field
-        null_vectorfield, null_vectorfield_bc = traversals_data.null_vector_field
-        return apply_vector(
-            *formulae_interpolate,
-            *advector.field,
-            *momentum_x.field,
-            momentum_x.bc,
-            *null_vectorfield,
-            null_vectorfield_bc,
-            *momentum_y.field,
-            momentum_y.bc,
-            traversals_data.buffer
-        )
-
-    return apply
-
-
 def make_hooks(*, traversals, options, grid_step, time_step):
 
     divide_or_zero = make_divide_or_zero(options, traversals)
-    interpolate = make_interpolate(options, traversals)
-    rhs_x = make_rhs(grid_step, time_step, OUTER, options, traversals)
-    rhs_y = make_rhs(grid_step, time_step, INNER, options, traversals)
+    interpolate = formulae.make_interpolate(options, traversals)
+    rhs_x = formulae.make_rhs(grid_step, time_step, OUTER, options, traversals)
+    rhs_y = formulae.make_rhs(grid_step, time_step, INNER, options, traversals)
 
     @numba.experimental.jitclass([])
-    class AnteStep:
+    class AnteStep:  # pylint:disable=too-few-public-methods
         def __init__(self):
             pass
 
@@ -118,7 +25,7 @@ def call(
             traversals_data,
             advectees,
             advector,
-            step,
+            _,
             index,
             todo_outer,
             todo_mid3d,
@@ -143,11 +50,11 @@ def call(
                 rhs_y(traversals_data, advectees[index], advectees[0])
 
     @numba.experimental.jitclass([])
-    class PostStep:
+    class PostStep:  # pylint:disable=too-few-public-methods
         def __init__(self):
             pass
 
-        def call(self, traversals_data, advectees, step, index):
+        def call(self, traversals_data, advectees, _, index):
             if index == 0:
                 pass
             if index == 1:
@@ -208,7 +115,7 @@ def run(self):
                 output.append(
                     {
                         k: self.solver.advectee[k].get().copy()
-                        for k in self.advectees.keys()
+                        for k in self.advectees.keys()  # pylint:disable=consider-iterating-dictionary
                     }
                 )
         return output