Black for files in doc, bench, scripts

Makefile

@@ -28,7 +28,7 @@ shortlog:
  @hg log -M -r$(RELEASE): --template '- {desc|firstline} (:rev:`{node|short}`)\n'
 
 black:
- black -l 82 fluidsim
+ black -l 82 fluidsim scripts bench doc
 
 tests:
  fluidsim-test -v

bench/dedalus/ns2d.py

@@ -14,54 +14,56 @@
 from dedalus import public as de
 import time
 
-lx, ly = (1., 1.)
+lx, ly = (1.0, 1.0)
 nx, ny = (512, 512)
 
 # Create bases and domain
-x_basis = de.Fourier('x', nx, interval=(0, lx), dealias=3/2)
-y_basis = de.Fourier('y', ny, interval=(0, ly), dealias=3/2)
+x_basis = de.Fourier("x", nx, interval=(0, lx), dealias=3 / 2)
+y_basis = de.Fourier("y", ny, interval=(0, ly), dealias=3 / 2)
 domain = de.Domain([x_basis, y_basis], grid_dtype=np.float64)
 
 # Faster algorithm with vorticity?
-variables = ['p', 'u', 'v', 'uy', 'vy']
+variables = ["p", "u", "v", "uy", "vy"]
 problem = de.IVP(domain, variables=variables)
 
 Reynolds = 1e4
-problem.parameters['Re'] = Reynolds
+problem.parameters["Re"] = Reynolds
 
 problem.add_equation(
- 'dt(u) + dx(p) - 1/Re*(dx(dx(u)) + dy(uy)) = - u*dx(u) - v*uy')
+ "dt(u) + dx(p) - 1/Re*(dx(dx(u)) + dy(uy)) = - u*dx(u) - v*uy"
+)
 problem.add_equation(
- 'dt(v) + dy(p) - 1/Re*(dx(dx(v)) + dy(vy)) = - u*dx(v) - v*vy')
+ "dt(v) + dy(p) - 1/Re*(dx(dx(v)) + dy(vy)) = - u*dx(v) - v*vy"
+)
 
-problem.add_equation('dx(u) + vy = 0')
-problem.add_equation('uy - dy(u) = 0')
-problem.add_equation('vy - dy(v) = 0')
+problem.add_equation("dx(u) + vy = 0")
+problem.add_equation("uy - dy(u) = 0")
+problem.add_equation("vy - dy(v) = 0")
 
 ts = de.timesteppers.RK443
 
 solver = problem.build_solver(ts)
 
 x = domain.grid(0)
 y = domain.grid(1)
-u = solver.state['u']
-uy = solver.state['uy']
-v = solver.state['v']
-vy = solver.state['vy']
+u = solver.state["u"]
+uy = solver.state["uy"]
+v = solver.state["v"]
+vy = solver.state["vy"]
 
-u['g'] = np.ones_like(x)
-v['g'] = np.ones_like(x)
-u.differentiate('y', out=uy)
-v.differentiate('y', out=vy)
+u["g"] = np.ones_like(x)
+v["g"] = np.ones_like(x)
+u.differentiate("y", out=uy)
+v.differentiate("y", out=vy)
 
 dt = 1e-12
 
-print('Starting loop')
+print("Starting loop")
 start_time = time.time()
 
 for it in range(10):
  solver.step(dt)
 
 end_time = time.time()
 
-print('Run time: %f' %(end_time-start_time))
+print("Run time: %f" % (end_time - start_time))

bench/dedalus/ns2d_rot.py

@@ -20,45 +20,44 @@
 from dedalus import public as de
 
 
-lx, ly = (1., 1.)
+lx, ly = (1.0, 1.0)
 n = 1024
 nx, ny = (n, n)
 
 # Create bases and domain
-x_basis = de.Fourier('x', nx, interval=(0, lx), dealias=3/2)
-y_basis = de.Fourier('y', ny, interval=(0, ly), dealias=3/2)
+x_basis = de.Fourier("x", nx, interval=(0, lx), dealias=3 / 2)
+y_basis = de.Fourier("y", ny, interval=(0, ly), dealias=3 / 2)
 domain = de.Domain([x_basis, y_basis], grid_dtype=np.float64)
 
 # Stream function-vorticity formulation
-variables = ['rot', 'psi', 'u', 'v', 'rotx', 'roty']
+variables = ["rot", "psi", "u", "v", "rotx", "roty"]
 problem = de.IVP(domain, variables=variables)
 
 Reynolds = 1e4
-problem.parameters['Re'] = Reynolds
+problem.parameters["Re"] = Reynolds
 
-problem.add_equation(
- 'dt(rot) - (1/Re)*(dx(rotx) + dy(roty)) = - u*rotx - v*roty')
-problem.add_equation('dx(dx(psi)) + dy(dy(psi)) + rot = 0')
+problem.add_equation("dt(rot) - (1/Re)*(dx(rotx) + dy(roty)) = - u*rotx - v*roty")
+problem.add_equation("dx(dx(psi)) + dy(dy(psi)) + rot = 0")
 
 # with first-order reduction equations...
 # problem.add_equation('rot + dy(u) - dx(v) = 0')
-problem.add_equation('rotx - dx(rot) = 0')
-problem.add_equation('roty - dy(rot) = 0')
-problem.add_equation('v + dx(psi) = 0')
-problem.add_equation('u - dy(psi) = 0')
+problem.add_equation("rotx - dx(rot) = 0")
+problem.add_equation("roty - dy(rot) = 0")
+problem.add_equation("v + dx(psi) = 0")
+problem.add_equation("u - dy(psi) = 0")
 
 ts = de.timesteppers.RK443
 
 solver = problem.build_solver(ts)
 
 x = domain.grid(0)
 y = domain.grid(1)
-rot = solver.state['rot']
-psi = solver.state['psi']
-u = solver.state['u']
-v = solver.state['v']
-rotx = solver.state['rotx']
-roty = solver.state['roty']
+rot = solver.state["rot"]
+psi = solver.state["psi"]
+u = solver.state["u"]
+v = solver.state["v"]
+rotx = solver.state["rotx"]
+roty = solver.state["roty"]
 
 # Initial conditions
 
@@ -68,9 +67,9 @@
 # rot.differentiate('x', out=rotx)
 # rot.differentiate('y', out=roty)
 
-rot['g'] = gausspulse(np.sqrt((x - 0.5)**2 + (y - 0.5)**2), fc=1)
-rot.differentiate('x', out=rotx)
-rot.differentiate('y', out=roty)
+rot["g"] = gausspulse(np.sqrt((x - 0.5) ** 2 + (y - 0.5) ** 2), fc=1)
+rot.differentiate("x", out=rotx)
+rot.differentiate("y", out=roty)
 
 # psi['g'] = 10 * y
 # psi.differentiate('y', out=u)
@@ -82,12 +81,12 @@
 solver.stop_wall_time = np.inf
 solver.stop_iteration = 10
 
-print('Starting main time loop...')
+print("Starting main time loop...")
 start_time = time.time()
 
 for it in range(10):
  solver.step(dt)
 
 end_time = time.time()
 
-print('Run time for the loop: %f' %(end_time-start_time))
+print("Run time for the loop: %f" % (end_time - start_time))

bench/dedalus/ns2d_rot_faster.py

@@ -23,35 +23,36 @@
 from dedalus import public as de
 
 
-lx, ly = (1., 1.)
+lx, ly = (1.0, 1.0)
 
-nx = 512*2
+nx = 512 * 2
 
-coef_dealias = 2/3
+coef_dealias = 2 / 3
 
 n = int(coef_dealias * nx)
-dealias = nx/n
+dealias = nx / n
 nx, ny = (n, n)
 
 # Create bases and domain
-x_basis = de.Fourier('x', nx, interval=(0, lx), dealias=dealias)
-y_basis = de.Fourier('y', ny, interval=(0, ly), dealias=dealias)
+x_basis = de.Fourier("x", nx, interval=(0, lx), dealias=dealias)
+y_basis = de.Fourier("y", ny, interval=(0, ly), dealias=dealias)
 domain = de.Domain([x_basis, y_basis], grid_dtype=np.float64)
 
 # Stream function-vorticity formulation
-variables = ['psi']
+variables = ["psi"]
 problem = de.IVP(domain, variables=variables)
 
 Reynolds = 1e4
-problem.parameters['Re'] = Reynolds
-problem.substitutions['u'] = "dy(psi)"
-problem.substitutions['v'] = "-dx(psi)"
-problem.substitutions['rot'] = "- dx(dx(psi)) - dy(dy(psi))"
-problem.substitutions['rotx'] = "dx(rot)"
-problem.substitutions['roty'] = "dy(rot)"
+problem.parameters["Re"] = Reynolds
+problem.substitutions["u"] = "dy(psi)"
+problem.substitutions["v"] = "-dx(psi)"
+problem.substitutions["rot"] = "- dx(dx(psi)) - dy(dy(psi))"
+problem.substitutions["rotx"] = "dx(rot)"
+problem.substitutions["roty"] = "dy(rot)"
 problem.add_equation(
- 'dt(rot) - (1/Re)*(dx(rotx) + dy(roty)) = - u*rotx - v*roty',
- condition="(nx != 0) or (ny != 0)")
+ "dt(rot) - (1/Re)*(dx(rotx) + dy(roty)) = - u*rotx - v*roty",
+ condition="(nx != 0) or (ny != 0)",
+)
 problem.add_equation("psi = 0", condition="(nx == 0) and (ny == 0)")
 
 # with first-order reduction equations...
@@ -65,7 +66,7 @@
 
 x = domain.grid(0)
 y = domain.grid(1)
-psi = solver.state['psi']
+psi = solver.state["psi"]
 
 # Initial conditions
 
@@ -76,11 +77,11 @@
 # rot.differentiate('y', out=roty)
 
 rot = domain.new_field()
-rot['g'] = gausspulse(np.sqrt((x - 0.5)**2 + (y - 0.5)**2), fc=1)
+rot["g"] = gausspulse(np.sqrt((x - 0.5) ** 2 + (y - 0.5) ** 2), fc=1)
 kx = domain.elements(0)
 ky = domain.elements(1)
-k2 = kx**2 + ky**2
-psi['c'][k2 != 0] = rot['c'][k2 != 0] / k2[k2 != 0]
+k2 = kx ** 2 + ky ** 2
+psi["c"][k2 != 0] = rot["c"][k2 != 0] / k2[k2 != 0]
 
 # psi['g'] = 10 * y
 # psi.differentiate('y', out=u)
@@ -92,16 +93,16 @@
 solver.stop_wall_time = np.inf
 solver.stop_iteration = 10
 
-print('Starting startup loop...')
+print("Starting startup loop...")
 start_time = time.time()
 for it in range(10):
  solver.step(dt)
 end_time = time.time()
-print('Run time for startup loop: %f' %(end_time-start_time))
+print("Run time for startup loop: %f" % (end_time - start_time))
 
-print('Starting main time loop...')
+print("Starting main time loop...")
 start_time = time.time()
 for it in range(10):
  solver.step(dt)
 end_time = time.time()
-print('Run time for main loop: %f' %(end_time-start_time))
+print("Run time for main loop: %f" % (end_time - start_time))

bench/dedalus/ns2dstrat.py

@@ -15,73 +15,76 @@
 from dedalus import public as de
 import time
 
-lx, lz = (1., 1.)
+lx, lz = (1.0, 1.0)
 nz, nx = (512, 512)
 
 # Create bases and domain
-x_basis = de.Fourier('x', nx, interval=(0, lx), dealias=3/2)
-z_basis = de.Fourier('z', nz, interval=(0, lz), dealias=3/2)
+x_basis = de.Fourier("x", nx, interval=(0, lx), dealias=3 / 2)
+z_basis = de.Fourier("z", nz, interval=(0, lz), dealias=3 / 2)
 domain = de.Domain([x_basis, z_basis], grid_dtype=np.float64)
 
 # Faster algorithm with vorticity?
-variables = ['p', 'b', 'u', 'w', 'uz', 'wz', 'bz']
+variables = ["p", "b", "u", "w", "uz", "wz", "bz"]
 problem = de.IVP(domain, variables=variables)
 
 # Non-dimensional parameters
 Reynolds = 1e4
 Froude_horiz = 5e-1
-Schmidt = 1.
-Aspect_ratio = 1.
+Schmidt = 1.0
+Aspect_ratio = 1.0
 
-problem.parameters['Re'] = Reynolds
-problem.parameters['Fh'] = Froude_horiz
-problem.parameters['Sc'] = Schmidt
-problem.parameters['alpha'] = Aspect_ratio
+problem.parameters["Re"] = Reynolds
+problem.parameters["Fh"] = Froude_horiz
+problem.parameters["Sc"] = Schmidt
+problem.parameters["alpha"] = Aspect_ratio
 
 # Non-dimensional NS2D of stratified fluid.
 problem.add_equation(
- 'dt(u) + dx(p) - (1/(Re * alpha**2)) * ((alpha**2) * dx(dx(u)) + dz(uz)) = - u*dx(u) - w*uz')
+ "dt(u) + dx(p) - (1/(Re * alpha**2)) * ((alpha**2) * dx(dx(u)) + dz(uz)) = - u*dx(u) - w*uz"
+)
 problem.add_equation(
- '(Fh**2) * dt(w) + dz(p) + b - (1/(Re * alpha**2)) * ((alpha**2) * dx(dx(w)) + dz(wz)) = (Fh**2) * (- u*dx(w) - w*wz)')
+ "(Fh**2) * dt(w) + dz(p) + b - (1/(Re * alpha**2)) * ((alpha**2) * dx(dx(w)) + dz(wz)) = (Fh**2) * (- u*dx(w) - w*wz)"
+)
 
 problem.add_equation(
- 'dt(b) - uz - (1/(Re * Sc * alpha**2)) * ((alpha**2) * dx(dx(b)) + dz(bz)) = - u*dx(b) - w*bz')
+ "dt(b) - uz - (1/(Re * Sc * alpha**2)) * ((alpha**2) * dx(dx(b)) + dz(bz)) = - u*dx(b) - w*bz"
+)
 
-problem.add_equation('dx(u) + (Fh**2 / alpha**2) * wz = 0')
+problem.add_equation("dx(u) + (Fh**2 / alpha**2) * wz = 0")
 
 # with first-order reduction equations...
-problem.add_equation('uz - dz(u) = 0')
-problem.add_equation('wz - dz(w) = 0')
-problem.add_equation('bz - dz(b) = 0')
+problem.add_equation("uz - dz(u) = 0")
+problem.add_equation("wz - dz(w) = 0")
+problem.add_equation("bz - dz(b) = 0")
 
 ts = de.timesteppers.RK443
 
 solver = problem.build_solver(ts)
 
 x = domain.grid(0)
 z = domain.grid(1)
-u = solver.state['u']
-uz = solver.state['uz']
-w = solver.state['w']
-wz = solver.state['wz']
-b = solver.state['b']
-bz = solver.state['bz']
-
-u['g'] = np.ones_like(x)
-w['g'] = np.ones_like(x)
-b['g'] = np.ones_like(x)
-u.differentiate('z', out=uz)
-w.differentiate('z', out=wz)
-b.differentiate('z', out=bz)
+u = solver.state["u"]
+uz = solver.state["uz"]
+w = solver.state["w"]
+wz = solver.state["wz"]
+b = solver.state["b"]
+bz = solver.state["bz"]
+
+u["g"] = np.ones_like(x)
+w["g"] = np.ones_like(x)
+b["g"] = np.ones_like(x)
+u.differentiate("z", out=uz)
+w.differentiate("z", out=wz)
+b.differentiate("z", out=bz)
 
 dt = 1e-12
 
-print('Starting loop')
+print("Starting loop")
 start_time = time.time()
 
 for it in range(10):
  solver.step(dt)
 
 end_time = time.time()
 
-print('Run time: %f' %(end_time-start_time))
+print("Run time: %f" % (end_time - start_time))