Pass all ruff checks

Author: mwiesenberger

pyfeltor/dg/__init__.py

@@ -1,8 +1,12 @@
 # docstring displayed by help(pyfeltor)
 """ The python version of the dg library
 """
-from . import create
-from .enums import bc, direction, inverse_bc, inverse_dir
-from .grid import Grid
-from .evaluation import evaluate, integrate
-from . import geo
+from . import create as create
+from . import geo as geo
+from .enums import bc as bc
+from .enums import direction as direction
+from .enums import inverse_bc as inverse_bc
+from .enums import inverse_dir as inverse_dir
+from .evaluation import evaluate as evaluate
+from .evaluation import integrate as integrate
+from .grid import Grid as Grid

pyfeltor/dg/create/__init__.py

@@ -1,7 +1,11 @@
 # docstring displayed by help(pyfeltor)
 """ The python version of the dg library, creation
 """
-from .weights import weights, abscissas, grid_from_abscissas
-from .derivative import dx, jump
-from .elliptic import elliptic
-from .interpolation import interpolation, projection
+from .derivative import dx as dx
+from .derivative import jump as jump
+from .elliptic import elliptic as elliptic
+from .interpolation import interpolation as interpolation
+from .interpolation import projection as projection
+from .weights import abscissas as abscissas
+from .weights import grid_from_abscissas as grid_from_abscissas
+from .weights import weights as weights

pyfeltor/dg/create/derivative.py

@@ -1,6 +1,7 @@
-from .dx import normed, jump_normed
 import scipy.sparse
 
+from .dx import jump_normed, normed
+
 
 def dx(dim, grid, bc, direction):
     deriv = normed(grid.n[dim], grid.N[dim], grid.h()[dim], bc, direction)

pyfeltor/dg/create/dx.py

@@ -1,12 +1,12 @@
-import numpy as np
 import scipy.sparse
+
+from ..enums import bc
 from . import operators as ops
-from ..enums import bc, direction
 
 
 def symm(n, N, h, bcx):
-    l = ops.lilj(n)
-    r = ops.rirj(n)
+    ll = ops.lilj(n)
+    rr = ops.rirj(n)
     lr = ops.lirj(n)
     rl = ops.rilj(n)
     d = ops.pidxpj(n)
@@ -19,14 +19,14 @@ def symm(n, N, h, bcx):
     a_bound_left = a.copy()
     # left boundary
     if (bcx == bc.DIR) or (bcx == bc.DIR_NEU):
-        a_bound_left += 0.5 * (t @ l)
+        a_bound_left += 0.5 * (t @ ll)
     elif (bcx == bc.NEU) or (bcx == bc.NEU_DIR):
-        a_bound_left -= 0.5 * (t @ l)
+        a_bound_left -= 0.5 * (t @ ll)
     # right boundary
     if (bcx == bc.DIR) or (bcx == bc.NEU_DIR):
-        a_bound_right -= 0.5 * (t @ r)
+        a_bound_right -= 0.5 * (t @ rr)
     elif (bcx == bc.NEU) or (bcx == bc.DIR_NEU):
-        a_bound_right += 0.5 * (t @ r)
+        a_bound_right += 0.5 * (t @ rr)
     b = t @ (1.0 / 2.0 * rl)
     bp = t @ (-1.0 / 2.0 * lr)  # pitfall: T*-m^T is NOT -(T*m)^T
     # transform to XSPACE
@@ -94,20 +94,20 @@ def symm(n, N, h, bcx):
                     vals.append(b[i, j])
 
     # sort
-    rows, cols, vals = zip(*sorted(zip(rows, cols, vals)))
+    rows, cols, vals = zip(*sorted(zip(rows, cols, vals, strict=False)), strict=False)
     return scipy.sparse.coo_matrix((vals, (rows, cols)))
 
 
 def plus(n, N, h, bcx):
-    l = ops.lilj(n)
-    r = ops.rirj(n)
-    lr = ops.lirj(n)
+    ll = ops.lilj(n)
+    #rr = ops.rirj(n)
+    #lr = ops.lirj(n)
     rl = ops.rilj(n)
     d = ops.pidxpj(n)
     t = ops.pipj_inv(n)
     t *= 2.0 / h
 
-    a = t @ (-l - d.transpose())
+    a = t @ (-ll - d.transpose())
     # bcx = PER
     a_bound_left = a.copy()  # PER, NEU, and NEU_DIR
     a_bound_right = a.copy()  # PER, DIR, and NEU_DIR
@@ -168,20 +168,20 @@ def plus(n, N, h, bcx):
                     vals.append(b[i, j])
 
     # sort
-    rows, cols, vals = zip(*sorted(zip(rows, cols, vals)))
+    rows, cols, vals = zip(*sorted(zip(rows, cols, vals, strict=False)), strict=False)
     return scipy.sparse.coo_matrix((vals, (rows, cols)))
 
 
 def minus(n, N, h, bcx):
-    l = ops.lilj(n)
-    r = ops.rirj(n)
+    ll = ops.lilj(n)
+    #rr = ops.rirj(n)
     lr = ops.lirj(n)
-    rl = ops.rilj(n)
+    #rl = ops.rilj(n)
     d = ops.pidxpj(n)
     t = ops.pipj_inv(n)
     t *= 2.0 / h
 
-    a = t @ (l + d)
+    a = t @ (ll + d)
     # bcx = PER
     a_bound_right = a.copy()  # PER, NEU and DIR_NEU
     a_bound_left = a.copy()  # PER, DIR and DIR_NEU
@@ -242,25 +242,25 @@ def minus(n, N, h, bcx):
                     vals.append(a[i, j])
 
     # sort
-    rows, cols, vals = zip(*sorted(zip(rows, cols, vals)))
+    rows, cols, vals = zip(*sorted(zip(rows, cols, vals, strict=False)), strict=False)
     return scipy.sparse.coo_matrix((vals, (rows, cols)))
 
 
 def jump_normed(n, N, h, bcx):
-    l = ops.lilj(n)
-    r = ops.rirj(n)
+    ll = ops.lilj(n)
+    rr = ops.rirj(n)
     lr = ops.lirj(n)
     rl = ops.rilj(n)
 
     t = ops.pipj_inv(n)
     t *= 2.0 / h
-    a = t @ (l + r)
+    a = t @ (ll + rr)
     a_bound_left = a.copy()  # DIR and PER
     if (bcx == bc.NEU) or (bcx == bc.NEU_DIR):
-        a_bound_left = t @ r
+        a_bound_left = t @ rr
     a_bound_right = a.copy()  # DIR and PER
     if (bcx == bc.NEU) or (bcx == bc.DIR_NEU):
-        a_bound_right = t @ l
+        a_bound_right = t @ ll
     b = -t @ rl
     bp = -t @ lr
     # transform to XSPACE
@@ -328,7 +328,7 @@ def jump_normed(n, N, h, bcx):
                     vals.append(b[i, j])
 
     # sort
-    rows, cols, vals = zip(*sorted(zip(rows, cols, vals)))
+    rows, cols, vals = zip(*sorted(zip(rows, cols, vals, strict=False)), strict=False)
     return scipy.sparse.coo_matrix((vals, (rows, cols)))
 
 

pyfeltor/dg/create/elliptic.py

@@ -1,8 +1,8 @@
-import numpy as np
-from .derivative import dx, jump
-from .. import enums
 import scipy.sparse as sparse
 
+from .. import enums
+from .derivative import dx, jump
+
 
 def elliptic(grid, bcs, directions, sigma, jumpfactor=1):
     left = [

pyfeltor/dg/create/interpolation.py

@@ -1,10 +1,12 @@
-import numpy as np
 import itertools
+
+import numpy as np
 import scipy.sparse
-from .weights import weights
-from . import operators as ops
-from ..enums import bc, direction
+
+from ..enums import bc
 from ..evaluation import evaluate
+from . import operators as ops
+from .weights import weights
 
 
 def shift(grid, x, bcs):
@@ -76,24 +78,25 @@ def interpolation(xs, grid, bcs):
         else:
             raise Exception("interpolation not implemented for ndim > 3")
         for it in tuples:
-            I = 0  # the index to push back
-            V = 1  # the value to push back
+            II = 0  # the index to push back
+            VV = 1  # the value to push back
             for kk in range(0, grid.ndim):
-                I = (I * grid.N[kk] + nn[kk]) * grid.n[kk] + it[kk]
-                V = V * px[kk][it[kk]]
+                II = (II * grid.N[kk] + nn[kk]) * grid.n[kk] + it[kk]
+                VV = VV * px[kk][it[kk]]
             # print( i, I, V)
             rows.append(i)
-            cols.append(round(I))
+            cols.append(round(II))
             if not negative:
-                vals.append(V)
+                vals.append(VV)
             else:
-                vals.append(-V)
+                vals.append(-VV)
     # sort
-    rows, cols, vals = zip(*sorted(zip(rows, cols, vals)))
-    return scipy.sparse.coo_matrix((vals, (rows, cols)), shape = (len(xs[0]),grid.size()))
+    rows, cols, vals = zip(*sorted(zip(rows, cols, vals, strict=False)), strict=False)
+    return scipy.sparse.coo_matrix((vals, (rows, cols)), shape=(len(xs[0]),
+        grid.size()))
 
 
-def projection( grid_new, grid_old):
+def projection(grid_new, grid_old):
     """ Create a projection between two grids
 
     This matrix can be applied to vectors defined on the old (fine) grid to obtain
@@ -106,26 +109,28 @@ def projection( grid_new, grid_old):
     """
     ndim = grid_old.ndim
     if grid_new.ndim != ndim:
-        raise Exception( "Cannot project between grids with different dimensions")
-    for i in range( 0, ndim):
-        if grid_old.N[i] % grid_new.N[i] != 0 :
-            print( f"WARNING you project between incompatible grids!! old N: {grid_old.N[i]} new N {grid_new.N[i]}")
-        if grid_old.n[i] < grid_new.n[i]  :
-            print( f"WARNING you project between incompatible grids!! old n: {grid_old.n[i]} new n {grid_new.n[i]}")
-    wf = scipy.sparse.diags(weights( grid_old))
-    points = list()
-    bcs = [bc.PER for i in range(0,ndim)]
+        raise Exception("Cannot project between grids with different dimensions")
+    for i in range(0, ndim):
+        if grid_old.N[i] % grid_new.N[i] != 0:
+            print(f"WARNING you project between incompatible grids!! old N: \
+{grid_old.N[i]} new N {grid_new.N[i]}")
+        if grid_old.n[i] < grid_new.n[i]:
+            print(f"WARNING you project between incompatible grids!! old n: \
+{grid_old.n[i]} new n {grid_new.n[i]}")
+    wf = scipy.sparse.diags(weights(grid_old))
+    points = []
+    bcs = [bc.PER for i in range(0, ndim)]
     if ndim == 1:
-        points.append( evaluate( lambda x: x, grid_old))
+        points.append(evaluate(lambda x: x, grid_old))
     elif ndim == 2:
-        points.append( evaluate( lambda y,x: y, grid_old))
-        points.append( evaluate( lambda y,x: x, grid_old))
+        points.append(evaluate(lambda y, x: y, grid_old))
+        points.append(evaluate(lambda y, x: x, grid_old))
     elif ndim == 3:
-        points.append( evaluate( lambda z,y,x: z, grid_old))
-        points.append( evaluate( lambda z,y,x: y, grid_old))
-        points.append( evaluate( lambda z,y,x: x, grid_old))
+        points.append(evaluate(lambda z, y, x: z, grid_old))
+        points.append(evaluate(lambda z, y, x: y, grid_old))
+        points.append(evaluate(lambda z, y, x: x, grid_old))
     else:
         raise Exception("Projection not implemented for ndim > 3")
-    A = interpolation(  points, grid_new, bcs )
-    vc = scipy.sparse.diags(1./weights( grid_new))
+    A = interpolation(points, grid_new, bcs)
+    vc = scipy.sparse.diags(1. / weights(grid_new))
     return vc @ A.transpose() @ wf

pyfeltor/dg/create/operators.py

@@ -26,9 +26,8 @@ def pidxpj(n):
     op = np.zeros((n, n))
     for i in range(0, n):
         for j in range(0, n):
-            if i < j:
-                if (i + j) % 2 != 0:
-                    op[i, j] = 2
+            if (i < j) and ((i + j) % 2 != 0):
+                op[i, j] = 2
     return op
 
 

pyfeltor/dg/create/weights.py

@@ -1,4 +1,5 @@
 import numpy as np
+
 from ..grid import Grid
 
 
@@ -25,25 +26,27 @@ def abscissas(grid, dimension=0):
             abscissas[i * grid.n[dim] + k] = i * h + x0 + h / 2.0 * (1.0 + x[k])
     return abscissas
 
-def _get_x0_x1_n_N( x):
-    for n in range(1,21):
-        if  len(x)%n != 0:
+
+def _get_x0_x1_n_N(x):
+    for n in range(1, 21):
+        if len(x) % n != 0:
             continue
-        N = len(x)/n
+        N = len(x) / n
         (xx, w) = np.polynomial.legendre.leggauss(n)
         h = x[n] - x[0]
-        x0 = x[0] - h/2.0 * (1.0+xx[0])
-        first_absc = np.zeros(2*n)
-        last_value = x0 + h*N - h / 2.0 * (1.0 + xx[0])
-        for i in range(0,2):
-            for k in range(0,n):
-                first_absc[ i*n+k] = i * h  + x0 + h / 2.0 * (1.0 + xx[k])
-        if abs( last_value - x[-1]) < 1e-10*abs(x[-1]) + 1e-10:
-            return (x0, x0+h*N, int(n), int(N))
-    raise Exception( "Could not determine grid")
+        x0 = x[0] - h / 2.0 * (1.0 + xx[0])
+        first_absc = np.zeros(2 * n)
+        last_value = x0 + h * N - h / 2.0 * (1.0 + xx[0])
+        for i in range(0, 2):
+            for k in range(0, n):
+                first_absc[i * n + k] = i * h + x0 + h / 2.0 * (1.0 + xx[k])
+        if abs(last_value - x[-1]) < 1e-10 * abs(x[-1]) + 1e-10:
+            return (x0, x0 + h * N, int(n), int(N))
+    raise Exception("Could not determine grid")
     return (0, 1, 1, 1)
 
-def grid_from_abscissas( xs ) :
+
+def grid_from_abscissas(xs):
     """ This function reverse engineers a Grid that corresponds to the given
     abscissas. This is useful for example to get a Grid that corresponds to a
     given simulation output
@@ -58,6 +61,6 @@ def grid_from_abscissas( xs ) :
     x1 = np.zeros(ndim)
     n = np.arange(ndim)
     N = np.arange(ndim)
-    for dim in range(0,ndim):
+    for dim in range(0, ndim):
         x0[dim], x1[dim], n[dim], N[dim] = _get_x0_x1_n_N(xs[dim])
-    return Grid( x0, x1, n, N)
+    return Grid(x0, x1, n, N)

pyfeltor/dg/evaluation.py

@@ -1,20 +1,20 @@
-from .create import operators as ops
+import numpy as np
+
 from . import create
+from .create import operators as ops
 from .enums import direction
-import numpy as np
 
 
 def evaluate(function, grid):
     """Evaluate a function on the grid points of the given grid
 
     function: has to take numpy arrays as arguments, f(x), f(y,x), f(z,y,x)
     grid: instance of dg.Grid
-    return: flat np.array with x the fastest varying dimension. Can be reshaped with reshape(grid.shape)
+    return: flat np.array with x the fastest varying dimension. Can be reshaped
+    with reshape(grid.shape)
     """
-    xs = []
     ndim = grid.ndim
-    for dim in range(0, ndim):
-        xs.append(create.abscissas(grid, dim))
+    xs = [create.abscissas(grid, dim) for dim in range(0, ndim)]
 
     if ndim == 1:
         return np.array([function(x) for x in xs[0]])
@@ -59,8 +59,8 @@ def integrate(to_integrate, grid, direction=direction.forward):
     out = np.zeros(grid.size())
     for i in range(0, grid.N[0]):
         for k in range(0, grid.n[0]):
-            for l in range(0, grid.n[0]):
-                out[i * n + k] += ninj[k, l] * to_in[i * n + l]
+            for ll in range(0, grid.n[0]):
+                out[i * n + k] += ninj[k, ll] * to_in[i * n + ll]
             out[i * n + k] += constant
         for k in range(0, grid.n[0]):
             constant += h * forward[0, k] * to_in[i * n + k]