def test_channel(sol):
if sol in ('IPCS', 'IPCSR', 'KMM_mpifft4py', 'KMMRK3_mpifft4py'):
pytest.skip(sol+' not currently working')
config.update(
{
'Re': 8000.,
'nu': 1./8000., # Viscosity
'dt': 0.001, # Time step
'T': 0.01, # End time
'L': [2, 2*pi, 4*pi/3.],
'M': [7, 5, 2],
'eps': 1e-7
}, "channel"
)
solver = get_solver(regression_test=regression_test,
mesh="channel",
parse_args=[sol])
context = solver.get_context()
initialize(solver, context)
set_Source(**context)
solve(solver, context)
config.params.dealias = '3/2-rule'
config.params.optimization = 'cython'
reload_module(solver) # Need to reload to enable optimization
initialize(solver, context)
solve(solver, context)
config.params.dealias_cheb = True
config.params.checkpoint = 5
config.params.write_result = 2
initialize(solver, context)
solve(solver, context)
def test_channel(sol):
config.update(
{
'Re': 8000.,
'nu': 1./8000., # Viscosity
'dt': 0.001, # Time step
'T': 0.01, # End time
'L': [2, 2*pi, 4*pi/3.],
'M': [7, 5, 2],
'eps': 1e-7
}, "channel"
)
solver = get_solver(regression_test=regression_test,
mesh="channel",
parse_args=[sol])
context = solver.get_context()
initialize(solver, context)
set_Source(**context)
solve(solver, context)
config.params.dealias = '3/2-rule'
config.params.optimization = 'cython'
reload_module(solver) # Need to reload to enable optimization
initialize(solver, context)
solve(solver, context)
config.params.dealias_cheb = True
config.params.checkpoint = 5
config.params.write_result = 2
initialize(solver, context)
solve(solver, context)
def test_MHD(sol):
config.update({
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'eta': 0.01,
'L': [2 * pi, 4 * pi, 6 * pi],
'M': [4, 5, 6],
'convection': 'Divergence'
})
solver = get_solver(regression_test=regression_test, parse_args=sol)
context = solver.get_context()
initialize(**context)
solve(solver, context)
config.params.dealias = '3/2-rule'
initialize(**context)
solve(solver, context)
config.params.dealias = '2/3-rule'
config.params.optimization = 'cython'
reload_module(solver)
initialize(**context)
solve(solver, context)
config.params.write_result = 1
config.params.checkpoint = 1
config.dt = 0.01
config.params.t = 0.0
config.params.tstep = 0
config.T = 0.04
solver.regression_test = lambda c: None
solve(solver, context)
def test_solvers(sol):
config.update({
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'convection': 'Vortex'
})
solver = get_solver(regression_test=regression_test, parse_args=sol)
context = solver.get_context()
initialize(solver, context)
solve(solver, context)
config.params.make_profile = 1
config.params.dealias = '3/2-rule'
initialize(solver, context)
solve(solver, context)
config.params.dealias = '2/3-rule'
for opt in ('cython', 'numba', 'pythran'):
config.params.optimization = opt
reload_module(solver) # To load optimized methods
initialize(solver, context)
solve(solver, context)
config.params.write_result = 2
config.params.checkpoint = 2
config.params.dt = 0.01
config.params.t = 0.0
config.params.tstep = 0
config.params.T = 0.04
solver.regression_test = lambda c: None
solve(solver, context)
def test_NS2D(args):
config.update(
{
'nu': 0.01,
'dt': 0.05,
'T': 10
}, 'doublyperiodic')
solver = get_solver(regression_test=regression_test,
mesh='doublyperiodic',
parse_args=args)
context = solver.get_context()
initialize(solver, **context)
solve(solver, context)
config.params.dealias = '3/2-rule'
initialize(solver, **context)
solve(solver, context)
config.params.dealias = '2/3-rule'
config.params.optimization = 'cython'
reload_module(solver)
initialize(solver, **context)
solve(solver, context)
config.params.write_result = 1
config.params.checkpoint = 1
config.params.dt = 0.01
config.params.t = 0.0
config.params.tstep = 0
config.params.T = 0.04
solver.regression_test = lambda c: None
initialize(solver, **context)
solve(solver, context)
def test_NS2D(args):
config.update({'nu': 0.01, 'dt': 0.05, 'T': 10}, 'doublyperiodic')
solver = get_solver(regression_test=regression_test,
mesh='doublyperiodic',
parse_args=args)
context = solver.get_context()
initialize(**context)
solve(solver, context)
config.params.dealias = '3/2-rule'
initialize(**context)
solve(solver, context)
config.params.dealias = '2/3-rule'
config.params.optimization = 'cython'
reload_module(solver)
initialize(**context)
solve(solver, context)
config.params.write_result = 1
config.params.checkpoint = 1
config.params.dt = 0.01
config.params.t = 0.0
config.params.tstep = 0
config.params.T = 0.04
solver.regression_test = lambda c: None
initialize(**context)
solve(solver, context)
def test_channel(sol):
config.update(
{
'Re': 8000.,
'nu': 1. / 8000., # Viscosity
'dt': 0.001, # Time step
'T': 0.01, # End time
'L': [2 * pi, pi, 2],
'M': [2, 5, 7],
'eps': 1e-7
},
"channel")
solver = get_solver(regression_test=regression_test,
mesh="channel",
parse_args=[sol])
context = solver.get_context()
initialize(solver, context)
set_Source(**context)
solve(solver, context)
config.params.dealias = '3/2-rule'
config.params.optimization = 'cython'
reload_module(solver) # Need to reload to enable optimization
initialize(solver, context)
solve(solver, context)
config.params.dealias_cheb = True
config.params.checkpoint = 5
config.params.write_result = 2
initialize(solver, context)
solve(solver, context)
def test_integrators(sol):
config.update({
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'convection': 'Vortex'
})
solver = get_solver(regression_test=regression_test, parse_args=sol)
context = solver.get_context()
for integrator in ('RK4', 'ForwardEuler', 'AB2', 'BS5_adaptive',
'BS5_fixed'):
if integrator in ('ForwardEuler', 'AB2'):
config.params.ntol = 4
else:
config.params.ntol = 7
config.params.integrator = integrator
initialize(solver, context)
solve(solver, context)
def test_integrators(sol):
config.update(
{
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'convection': 'Vortex'
}
)
solver = get_solver(regression_test=regression_test, parse_args=sol)
context = solver.get_context()
for integrator in ('RK4', 'ForwardEuler', 'AB2', 'BS5_adaptive', 'BS5_fixed'):
if integrator in ('ForwardEuler', 'AB2'):
config.params.ntol = 4
else:
config.params.ntol = 7
config.params.integrator = integrator
initialize(solver, context)
solve(solver, context)
def test_solvers(sol):
config.update(
{
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'convection': 'Vortex'
}
)
solver = get_solver(regression_test=regression_test,
parse_args=sol)
context = solver.get_context()
initialize(solver, context)
solve(solver, context)
config.params.make_profile = 1
config.params.dealias = '3/2-rule'
initialize(solver, context)
solve(solver, context)
config.params.dealias = '2/3-rule'
for opt in ('cython', 'numba', 'pythran'):
config.params.optimization = opt
reload_module(solver) # To load optimized methods
initialize(solver, context)
solve(solver, context)
config.params.write_result = 2
config.params.checkpoint = 2
config.params.dt = 0.01
config.params.t = 0.0
config.params.tstep = 0
config.params.T = 0.04
solver.regression_test = lambda c: None
solve(solver, context)
solver = config.solver
U = solver.get_velocity(**context)
im.set_UVC(U[1, 0], U[2, 0])
plt.pause(1e-6)
if __name__ == "__main__":
config.update(
{
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 50, # End time
'write_result': 10
},
'triplyperiodic')
config.triplyperiodic.add_argument("--init",
default='random',
choices=('random', 'vortex'))
config.triplyperiodic.add_argument(
"--plot_step", type=int,
default=10) # required to allow overloading through commandline
solver = get_solver(update=update,
regression_test=regression_test,
mesh="triplyperiodic")
assert config.params.decomposition == 'slab'
context = solver.get_context()
initialize(**context)
set_source(**context)
solve(solver, context)
kk = comm.reduce(sum(U.astype(float64)*U.astype(float64))*dx[0]*dx[1]/L[0]/L[1]/2)
if rank == 0:
print tstep, kk
if __name__ == "__main__":
config.update(
{
'nu': 1.0e-08,
'dt': 0.001,
'T': 1.0,
'U1':-0.5,
'U2':0.5,
'l0': 0.001, # Smoothing parameter
'A': 0.01, # Amplitude of perturbation
'Ri': 0.167, # Richardson number
'Pr': 12.0, # Prantl number
'delta': 0.05, # Width of perturbations
'bb': 0.8,
'k0': 2,
'rho1': 1.0,
'rho2': 3.0,
}, 'doublyperiodic'
)
config.doublyperiodic.add_argument("--plot_result", type=int, default=10)
config.doublyperiodic.add_argument("--compute_energy", type=int, default=2)
solver = get_solver(update, mesh='doublyperiodic')
solver.hdf5file.components["curl"] = solver.curl
initialize(**vars(solver))
solver.solve()
if rank == 0:
print tstep, kk
if __name__ == "__main__":
config.update(
{
'nu': 1.0e-08,
'dt': 0.001,
'T': 1.0,
'U1': -0.5,
'U2': 0.5,
'l0': 0.001, # Smoothing parameter
'A': 0.01, # Amplitude of perturbation
'Ri': 0.167, # Richardson number
'Pr': 12.0, # Prantl number
'delta': 0.05, # Width of perturbations
'bb': 0.8,
'k0': 2,
'rho1': 1.0,
'rho2': 3.0,
},
'doublyperiodic')
config.doublyperiodic.add_argument("--plot_result", type=int, default=10)
config.doublyperiodic.add_argument("--compute_energy", type=int, default=2)
solver = get_solver(update, mesh='doublyperiodic')
solver.hdf5file.components["curl"] = solver.curl
initialize(**vars(solver))
solver.solve()
"triplyperiodic")
config.triplyperiodic.add_argument("--N",
default=[60, 60, 60],
nargs=3,
help="Mesh size. Trumps M.")
config.triplyperiodic.add_argument("--compute_energy",
type=int,
default=10)
config.triplyperiodic.add_argument("--compute_spectrum",
type=int,
default=1000)
config.triplyperiodic.add_argument("--plot_step", type=int, default=1000)
config.triplyperiodic.add_argument("--Kf2", type=int, default=3)
config.triplyperiodic.add_argument("--kd", type=float, default=50.)
config.triplyperiodic.add_argument("--Re_lam", type=float, default=84.)
sol = get_solver(update=update, mesh="triplyperiodic")
config.params.nu = (1. / config.params.kd**(4. / 3.))
context = sol.get_context()
initialize(sol, context)
#init_from_file("NS_isotropic_6_6_6b.h5", sol, context)
Ek, bins, E0, E1, E2 = spectrum(sol, context)
context.hdf5file.fname = "NS_isotropic_{}_{}_{}b.h5".format(
*config.params.N)
context.hdf5file.f = h5py.File(context.hdf5file.fname,
driver='mpio',
comm=sol.comm)
context.hdf5file._init_h5file(config.params, sol)
context.hdf5file.f.create_group("Turbulence")
context.hdf5file.f["Turbulence"].create_group("Ek")
# current timestep
U_hat[:] = f["U/Vector/3D/0"][su]
context.g[:] = 1j*context.K[1]*U_hat[2] - 1j*context.K[2]*U_hat[1]
f.close()
if __name__ == "__main__":
config.update(
{'nu': 1./180., # Viscosity
'Re_tau': 180.,
'dt': 0.0005, # Time step
'T': 100., # End time
'L': [2, 2*np.pi, np.pi],
'M': [6, 6, 6],
'dealias': '3/2-rule'
}, "channel"
)
config.channel.add_argument("--compute_energy", type=int, default=10)
config.channel.add_argument("--plot_result", type=int, default=100)
config.channel.add_argument("--sample_stats", type=int, default=1000)
config.channel.add_argument("--print_energy0", type=int, default=10)
#solver = get_solver(update=update, mesh="channel")
solver = get_solver(update=update, mesh="channel")
context = solver.get_context()
initialize(solver, context)
#init_from_file("KMM666d.h5_c.h5", solver, context)
set_Source(**context)
solver.stats = Stats(context.U, solver.comm, filename="KMMstatsq")
context.hdf5file.filename = "KMM666e"
solve(solver, context)
U0[i] = FST.ifst(U_hat0[i], U0[i], ST)
U_hat0[0] = FST.fst(U0[0], U_hat0[0], SB)
for i in range(1, 3):
U_hat0[i] = FST.fst(U0[i], U_hat0[i], ST)
if __name__ == "__main__":
config.update(
{
'Re': 8000.,
'nu': 1./8000., # Viscosity
'dt': 0.01, # Time step
'T': 0.01, # End time
'L': [2, 2*pi, 4*pi/3.],
'M': [7, 5, 2]
}, "channel"
)
config.channel.add_argument("--compute_energy", type=int, default=1)
config.channel.add_argument("--plot_step", type=int, default=1)
solver = get_solver(update=update, regression_test=regression_test, mesh="channel")
vars(solver).update(initialize(**vars(solver)))
set_Source(**vars(solver))
solver.solve()
#s = solver
#s.FST.padsize = 2.0
#U0 = s.FST.get_workarray(((3,)+s.FST.real_shape_padded(), s.float), 0)
#U0[0] = s.FST.ifst(s.U_hat[0], U0[0], s.SB, dealias="3/2-rule")
#U0[1] = s.FST.ifst(s.U_hat[1], U0[1], s.ST, dealias="3/2-rule")
#U0[2] = s.FST.ifst(s.U_hat[2], U0[2], s.ST, dealias="3/2-rule")
if config.solver == 'NS':
curl[:] = Curl(U_hat, curl)
w = comm.reduce(
sum(curl.astype(float64) * curl.astype(float64)) * dx[0] * dx[1] *
dx[2] / L[0] / L[1] / L[2] / 2)
elif config.solver == 'VV':
U = Curl(kw['W_hat'], U)
w = comm.reduce(
sum(kw['W'].astype(float64) * kw['W'].astype(float64)) * dx[0] *
dx[1] * dx[2] / L[0] / L[1] / L[2] / 2)
k = comm.reduce(
sum(U.astype(float64) * U.astype(float64)) * dx[0] * dx[1] * dx[2] /
L[0] / L[1] / L[2] / 2) # Compute energy with double precision
if rank == 0:
assert round(k - 0.124953117517, 7) == 0
assert round(w - 0.375249930801, 7) == 0
if __name__ == "__main__":
config.update({
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'L': [2 * pi, 2 * pi, 2 * pi],
'M': [5, 5, 5]
})
solver = get_solver(update=update, regression_test=regression_test)
initialize(**vars(solver))
solver.solve()
config.t, linalg.norm(u_exact - U[1, :, 0, 0], inf))
plt.plot(X[0][:, 0, 0], U[1, :, 0, 0], X[0][:, 0, 0], u_exact, '*r')
plt.show()
if __name__ == "__main__":
config.update(
{
'solver': 'IPCS_MHD',
'Re': 8000.,
'Rm': 600.,
'nu': 1. / 8000., # Viscosity
'eta': 1. / 600., # Resistivity
'dt': 0.001, # Time step
'T': 0.01, # End time
'B_strength': 0.000001,
'Ha': 0.0043817804600413289,
'L': [2, 2 * pi, 4 * pi / 3.],
'M': [7, 6, 1]
},
"ShenMHD")
config.ShenMHD.add_argument("--compute_energy", type=int, default=1)
config.ShenMHD.add_argument("--plot_step", type=int, default=10)
solver = get_solver(update=update,
regression_test=regression_test,
family="ShenMHD")
vars(solver).update(initialize(**vars(solver)))
set_Source(**vars(solver))
solver.solve()
im.set_UVC(U[1, 0], U[2, 0])
im2.set_data(W[0, 0, :, ::-1].T)
im2.autoscale()
plt.pause(1e-6)
print "Time = ", t
def finalize(rank, Nf, X, U, W_hat, Curl, **soak):
global im
im.set_UVC(U[1, 0], U[2, 0])
plt.pause(1e-6)
if __name__ == "__main__":
config.update(
{
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 50, # End time
'write_result': 100
}
)
config.triplyperiodic.add_argument("--init", default='random', choices=('random', 'vortex'))
config.triplyperiodic.add_argument("--plot_result", type=int, default=10) # required to allow overloading through commandline
solver = get_solver(update=update, mesh="triplyperiodic")
assert config.decomposition == 'slab'
solver.W, solver.W_hat = initialize(**vars(solver))
solver.Source = set_source(**vars(solver))
solver.solve()
finalize(**vars(solver))
params = config.params
solver = config.solver
dx, L = params.dx, params.L
UB = solver.get_UB(**context)
U, B = UB[:3], UB[3:]
k = solver.comm.reduce(
sum(U.astype(float64) * U.astype(float64)) * dx[0] * dx[1] * dx[2] /
L[0] / L[1] / L[2] / 2) # Compute energy with double precision
b = solver.comm.reduce(
sum(B.astype(float64) * B.astype(float64)) * dx[0] * dx[1] * dx[2] /
L[0] / L[1] / L[2] / 2)
if solver.rank == 0:
assert round(k - 0.124565408177, 7) == 0
assert round(b - 0.124637762143, 7) == 0
if __name__ == '__main__':
config.update({
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'eta': 0.01,
'L': [2 * pi, 4 * pi, 6 * pi],
'M': [4, 5, 6],
'convection': 'Divergence'
})
solver = get_solver(regression_test=regression_test)
context = solver.get_context()
initialize(**context)
solve(solver, context)
if hdf5file.check_if_write(tstep):
P = FFT.ifftn(P_hat*1j, P)
hdf5file.write(tstep)
def regression_test(t, tstep, comm, U_hat, U, curl, float64, dx, L, sum, rank, Curl, **kw):
if config.solver == 'NS':
curl[:] = Curl(U_hat, curl)
w = comm.reduce(sum(curl.astype(float64)*curl.astype(float64))*dx[0]*dx[1]*dx[2]/L[0]/L[1]/L[2]/2)
elif config.solver == 'VV':
U = Curl(kw['W_hat'], U)
w = comm.reduce(sum(kw['W'].astype(float64)*kw['W'].astype(float64))*dx[0]*dx[1]*dx[2]/L[0]/L[1]/L[2]/2)
k = comm.reduce(sum(U.astype(float64)*U.astype(float64))*dx[0]*dx[1]*dx[2]/L[0]/L[1]/L[2]/2) # Compute energy with double precision
if rank == 0:
assert round(k - 0.124953117517, 7) == 0
assert round(w - 0.375249930801, 7) == 0
if __name__ == "__main__":
config.update(
{
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'L': [2*pi, 2*pi, 2*pi],
'M': [5, 5, 5]
}
)
solver = get_solver(update=update, regression_test=regression_test)
initialize(**vars(solver))
solver.solve()
self.Pmean[:] = self.f0["Average/P"][s] * Nd
for i, name in enumerate(("UU", "VV", "WW", "UV", "UW", "VW")):
self.UU[i, :] = self.f0["Reynolds Stress/" + name][s] * Nd
self.f0.close()
if __name__ == "__main__":
config.update(
{
'nu': 1. / 590., # Viscosity
'Re_tau': 590.,
'dt': 0.0005, # Time step
'T': 100., # End time
'L': [2, 2 * pi, pi],
'M': [6, 6, 6]
},
"channel")
config.channel.add_argument("--compute_energy", type=int, default=10)
config.channel.add_argument("--plot_result", type=int, default=10)
config.channel.add_argument("--sample_stats", type=int, default=10)
config.channel.add_argument("--print_energy0", type=int, default=10)
#solver = get_solver(update=update, mesh="channel")
solver = get_solver(update=update, mesh="channel")
context = solver.get_context()
initialize(solver, context)
#init_from_file("KMM665b.h5", solver, context)
set_Source(**context)
solver.stats = Stats(context.U, solver.comm, filename="KMMstatsq")
context.hdf5file.fname = "KMM665c.h5"
solve(solver, context)
plt.pause(1e-6)
print("Time = ", params.t)
def regression_test(context):
global im
solver = config.solver
U = solver.get_velocity(**context)
im.set_UVC(U[1, :, :, 0], U[2, :, :, 0])
plt.pause(1e-6)
if __name__ == "__main__":
config.update(
{'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 50, # End time
'write_result': 10
}, 'triplyperiodic')
config.triplyperiodic.add_argument("--init", default='random', choices=('random', 'vortex'))
config.triplyperiodic.add_argument("--plot_step", type=int, default=10) # required to allow overloading through commandline
solver = get_solver(update=update,
regression_test=regression_test,
mesh="triplyperiodic")
assert config.params.solver == 'VV'
assert config.params.decomposition == 'slab'
context = solver.get_context()
initialize(**context)
set_source(**context)
solve(solver, context)
U[0] = -sin(context.X[1]) * cos(context.X[0]) * exp(
-2 * params.nu * params.t)
U[1] = sin(context.X[0]) * cos(context.X[1]) * exp(
-2 * params.nu * params.t)
ke = solver.comm.reduce(
sum(U.astype(float64) * U.astype(float64)) * dx[0] * dx[1] / L[0] /
L[1] / 2)
if solver.rank == 0:
print("Error {}".format(k - ke))
assert round(k - ke, params.ntol) == 0
if __name__ == '__main__':
config.update(
{
'nu': 0.01,
'dt': 0.05,
'T': 10,
'write_result': 100,
'M': [6, 6]
}, 'doublyperiodic')
config.doublyperiodic.add_argument(
"--plot_result", type=int,
default=10) # required to allow overloading through commandline
sol = get_solver(update=update,
regression_test=regression_test,
mesh="doublyperiodic")
context = sol.get_context()
initialize(**context)
solve(sol, context)
**kw):
if "KMM" in config.solver:
U[0] = FST.ifst(U_hat[0], U[0], kw["SB"])
for i in range(1, 3):
U[i] = FST.ifst(U_hat[i], U[i], kw["ST"])
initOS(OS, U0, U_hat0, X, t=config.t)
pert = (U[0] - U0[0])**2 + (U[1] - U0[1])**2
e1 = 0.5 * energy(pert, N, comm, rank, L)
if rank == 0:
assert sqrt(e1) < 1e-12
if __name__ == "__main__":
config.update(
{
'Re': 8000.,
'nu': 1. / 8000., # Viscosity
'dt': 0.001, # Time step
'T': 0.01, # End time
'L': [2, 2 * pi, 4 * pi / 3.],
'M': [7, 6, 2]
},
"channel")
config.channel.add_argument("--compute_energy", type=int, default=1)
config.channel.add_argument("--plot_step", type=int, default=1)
solver = get_solver(regression_test=regression_test, mesh="channel")
vars(solver).update(initialize(**vars(solver)))
set_Source(**vars(solver))
solver.solve()
curl = solver.get_curl(**context)
im.set_data(curl[:, :])
im.autoscale()
plt.pause(1e-6)
def regression_test(context):
params = config.params
solver = config.solver
dx, L = params.dx, params.L
U = solver.get_velocity(**context)
k = solver.comm.reduce(sum(U.astype(float64)*U.astype(float64))*dx[0]*dx[1]/L[0]/L[1]/2)
U[0] = -sin(context.X[1])*cos(context.X[0])*exp(-2*params.nu*params.t)
U[1] = sin(context.X[0])*cos(context.X[1])*exp(-2*params.nu*params.t)
ke = solver.comm.reduce(sum(U.astype(float64)*U.astype(float64))*dx[0]*dx[1]/L[0]/L[1]/2)
if solver.rank == 0:
print("Error {}".format(k-ke))
assert round(float(k - ke), params.ntol) == 0
if __name__ == '__main__':
config.update(
{'nu': 0.01,
'dt': 0.05,
'T': 10,
'write_result': 100,
'M': [6, 6]}, 'doublyperiodic')
config.doublyperiodic.add_argument("--plot_result", type=int, default=10) # required to allow overloading through commandline
sol = get_solver(update=update, regression_test=regression_test, mesh="doublyperiodic")
context = sol.get_context()
initialize(sol, **context)
solve(sol, context)
B[2] = 0
UB_hat = UB.forward(UB_hat)
config.params.t = 0
config.params.tstep = 0
def regression_test(context):
params = config.params
solver = config.solver
dx, L = params.dx, params.L
UB = context.UB_hat.backward(context.UB)
U, B = UB[:3], UB[3:]
k = solver.comm.reduce(sum(U.astype(float64)*U.astype(float64))*dx[0]*dx[1]*dx[2]/L[0]/L[1]/L[2]/2) # Compute energy with double precision
b = solver.comm.reduce(sum(B.astype(float64)*B.astype(float64))*dx[0]*dx[1]*dx[2]/L[0]/L[1]/L[2]/2)
if solver.rank == 0:
assert round(float(k) - 0.124565408177, 7) == 0
assert round(float(b) - 0.124637762143, 7) == 0
if __name__ == '__main__':
config.update(
{'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'eta': 0.01,
'L': [2*pi, 4*pi, 6*pi],
'M': [4, 5, 6],
'convection': 'Divergence'})
solver = get_solver(regression_test=regression_test)
context = solver.get_context()
initialize(**context)
solve(solver, context)
solver.comm.Gather(u0, uall, root=0)
if solver.rank == 0:
uall = uall.reshape((params.N[0],))
x0 = context.X[0][:, 0, 0]
#x = x0
#pc = zeros(len(x))
#pc = ST.fct(uall, pc) # Cheb transform of result
#solution at x = 0
#u = n_cheb.chebval(0, pc)
#u_exact = reference(params.Re, params.t)
u_exact = exact(x0, params.Re, params.t)
print("Computed error = %2.8e %2.8e " %(np.sqrt(np.sum((uall-u_exact)**2)/params.N[0]), params.dt))
if __name__ == "__main__":
config.update(
{'Re': 800.,
'nu': 1./800., # Viscosity
'dt': 0.5, # Time step
'T': 50., # End time
'L': [2, 2*np.pi, 4*np.pi/3.],
'M': [6, 5, 2]
}, "channel"
)
config.channel.add_argument("--compute_energy", type=int, default=5)
config.channel.add_argument("--plot_step", type=int, default=10)
solver = get_solver(update=update, regression_test=regression_test, mesh="channel")
context = solver.get_context()
initialize(**context)
set_Source(**context)
solve(solver, context)
config.update(
{
'nu': U * L / Re,
'dt': dt,
'T': 11 * dt, # Should run 10 iterations
'write_result': 100,
'L': [L, L],
'M': [10, 10] # Mesh size is pow(2, M[i]) in direction i
# 2**9 == 512
},
'doublyperiodic')
# required to allow overloading through commandline
config.doublyperiodic.add_argument("--plot_result", type=int, default=10)
if plt is None:
sol = get_solver(mesh="doublyperiodic")
else:
sol = get_solver(update=update, mesh="doublyperiodic")
context = sol.get_context()
initialize(**context)
# Double check benchmark walltime
start_time = time.time()
cProfile.runctx('solve(sol, context)', globals(), locals(),
'profile.pstats')
end_time = time.time()
print('Run time: %f' % (end_time - start_time))
s = pstats.Stats('profile.pstats')
s.sort_stats('time').print_stats(12)
