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_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_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_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_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_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)
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 'VV' in config.params.solver:
context.W_hat = solver.cross2(context.W_hat, context.K, context.U_hat)
context.target_energy = energy_fourier(U_hat, context.T)
f.close()
if __name__ == "__main__":
import h5py
config.update(
{
'nu': 0.005428, # Viscosity (not used, see below)
'dt': 0.002, # Time step
'T': 5, # End time
'L': [2. * pi, 2. * pi, 2. * pi],
'checkpoint': 100,
'write_result': 1e8,
'dealias': '3/2-rule',
},
"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=100)
config.triplyperiodic.add_argument("--compute_spectrum",
type=int,
default=1000)
self.fname = filename
self.f0 = h5py.File(filename+".h5", "a", driver="mpio", comm=self.comm)
N = self.shape[0]
s = slice(self.rank*N, (self.rank+1)*N, 1)
for i, name in enumerate(("U", "V", "W")):
self.Umean[i, :] = self.f0["Average/"+name][s]
self.Pmean[:] = self.f0["Average/P"][s]
for i, name in enumerate(("UU", "VV", "WW", "UV", "UW", "VW")):
self.UU[i, :] = self.f0["Reynolds Stress/"+name][s]
if __name__ == "__main__":
config.update(
{
'nu': 1./180., # Viscosity
'Re_tau': 180.,
'dt': 0.001, # Time step
'T': 100., # End time
'L': [2, 4*pi, 4.*pi/3.],
'M': [6, 6, 5]
}, "channel"
)
config.channel.add_argument("--compute_energy", type=int, default=100)
config.channel.add_argument("--plot_result", type=int, default=100)
config.channel.add_argument("--sample_stats", type=int, default=100)
config.channel.add_argument("--print_energy0", type=int, default=100)
solver = get_solver(update=update, mesh="channel")
initialize(**vars(solver))
#init_from_file("KMM666.h5", **vars(solver))
set_Source(**vars(solver))
solver.stats = Stats(solver.U, solver.comm, filename="KMMstats")
solver.hdf5file.fname = "KMM665.h5"
solver.solve()
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()
if 'VV' in config.params.solver:
context.W_hat = solver.cross2(context.W_hat, context.K, context.U_hat)
context.target_energy = energy_fourier(solver.comm, U_hat)
f.close()
if __name__ == "__main__":
import h5py
config.update(
{
'nu': 0.005428, # Viscosity (not used, see below)
'dt': 0.002, # Time step
'T': 5, # End time
'L': [2. * pi, 2. * pi, 2. * pi],
'checkpoint': 100,
'write_result': 1e8,
'mask_nyquist': True,
},
"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)
im2.set_data(curl[:, :].T)
im2.autoscale()
plt.pause(1e-6)
plt.savefig("KH_{}.png".format(count))
if solver.rank == 0:
print(params.tstep)
if __name__ == "__main__":
config.update(
{
'nu': 1.0e-05,
'dt': 0.007,
'T': 25.0,
'U1': -0.5,
'U2': 0.5,
'l0': 0.001, # Smoothing parameter
'A': 0.01, # Amplitude of perturbation
'delta': 0.1, # Width of perturbations
'write_result': 500
},
'doublyperiodic')
# Adding new arguments required here to allow overloading through commandline
config.doublyperiodic.add_argument('--plot_result', type=int, default=50)
config.doublyperiodic.add_argument('--compute_energy',
type=int,
default=50)
solver = get_solver(update=update, mesh='doublyperiodic')
assert config.params.solver == 'NS2D'
context = solver.get_context()
initialize(**context)
if config.solver.rank == 0:
print(r" %2d & %2.8e & %2.8e \\\ " %(-int(log10(config.params.eps)), sqrt(e2)/config.params.eps, e1/e0-exact))
def spatial_refinement_test(context):
_, e2, _ = compute_error(context)
if config.solver.rank == 0:
print(r" %2d & %2.8e & %2.8e \\\ " %(2**config.params.M[0], sqrt(e2)/config.params.eps, acc[0]))
if __name__ == "__main__":
config.update(
{'Re': 8000.,
'nu': 1./8000., # Viscosity
'dt': 0.001, # Time step
'T': 0.01, # End time
'L': [2*pi, pi, 2],
'M': [5, 2, 7],
'Dquad': 'GC',
'Bquad': 'GC',
'mask_nyquist': True,
'dealias': None
}, "channel"
)
config.channel.add_argument("--compute_energy", type=int, default=1)
config.channel.add_argument("--plot_step", type=int, default=1)
config.channel.add_argument("--refinement_test", type=bool, default=False)
config.channel.add_argument("--eps_refinement_test", type=bool, default=False)
config.channel.add_argument("--spatial_refinement_test", type=bool, default=False)
config.channel.add_argument("--eps", type=float, default=1e-7)
#solver = get_solver(update=update, regression_test=regression_test, mesh="channel")
solver = get_solver(update=update, mesh="channel")
U_hat[:] = f["U/Vector/3D/0"][su]
phi_hat[:] = f["phi/3D/0"][sp]
context.g[:] = 1j * context.K[1] * U_hat[2] - 1j * context.K[2] * U_hat[1]
context.hdf5file.filename = filename
if 'tstep' in f.attrs:
config.params.tstep = f.attrs['tstep']
if 't' in f.attrs:
config.params.tstep = f.attrs['t']
f.close()
if __name__ == "__main__":
config.update(
{
'dt': 0.01, # Time step
'T': 1000., # End time
'L': [2, 2 * np.pi, 2 * np.pi],
'M': [6, 7, 7],
},
"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("--Ra", type=float, default=10000.0)
config.channel.add_argument("--Pr", type=float, default=0.7)
config.channel.add_argument("--sample_stats", type=int, default=10)
solver = get_solver(update=update, mesh="channel")
config.params.nu = np.sqrt(config.params.Pr / config.params.Ra)
config.params.kappa = 1. / np.sqrt(config.params.Pr * config.params.Ra)
context = solver.get_context()
initialize(solver, context)
#init_from_file("KMMRK3_RB_677g_c.h5", solver, context)
context.hdf5file.filename = "KMM_RB_677a"
U = solver.get_velocity(**context)
kk = solver.comm.reduce(sum(U.astype(float64)*U.astype(float64))*dx[0]*dx[1]/L[0]/L[1]/2)
if solver.rank == 0:
print(params.tstep, params.t, kk)
if __name__ == "__main__":
config.update(
{'nu': 1.0e-03,
'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,
'mask_nyquist': True,
'integrator': 'BS5_adaptive'
}, 'doublyperiodic'
)
config.doublyperiodic.add_argument("--plot_result", type=int, default=10)
config.doublyperiodic.add_argument("--compute_energy", type=int, default=2)
sol = get_solver(update=update, mesh='doublyperiodic')
context = sol.get_context()
initialize(**context)
solve(sol, context)
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))
hdf5file.write(params)
def regression_test(comm, U, B, float64, sum, rank, params, **kw):
dx, L = params.dx, params.L
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
b = comm.reduce(sum(B.astype(float64)*B.astype(float64))*dx[0]*dx[1]*dx[2]/L[0]/L[1]/L[2]/2)
if 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]
}
)
solver = get_solver(update=update, regression_test=regression_test)
initialize(**vars(solver))
solver.solve()
config.params.dealias = '3/2-rule'
initialize(**vars(solver))
solver.solve()
config.params.dealias = '2/3-rule'
config.params.optimization = 'cython'
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)
U0[0] = FST.ifst(U_hat0[0], U0[0], SB)
for i in range(1, 3):
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")
if tstep % config.compute_energy == 0:
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()
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
def additional_callback(**kw):
pass
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],
#'decomposition': 'pencil',
#'Pencil_alignment': 'Y',
#'P1': 2
}, "triplyperiodic"
)
config.triplyperiodic.add_argument("--compute_energy", type=int, default=2)
config.triplyperiodic.add_argument("--plot_step", type=int, default=10)
#solver = get_solver(update=update, regression_test=regression_test,
#additional_callback=additional_callback,
#mesh="triplyperiodic")
solver = get_solver(update=update, mesh="triplyperiodic")
#solver.hdf5file.fname = "NS7.h5"
#solver.hdf5file.components["W0"] = solver.curl[0]
#solver.hdf5file.components["W1"] = solver.curl[1]
e1, e2, exact = compute_error(context)
if config.solver.rank == 0:
print(r" %2d & %2.8e & %2.8e \\\ " %(-int(log10(config.params.eps)), sqrt(e2)/config.params.eps, e1/e0-exact))
def spatial_refinement_test(context):
_, e2, _ = compute_error(context)
if config.solver.rank == 0:
print(r" %2d & %2.8e & %2.8e \\\ " %(2**config.params.M[0], sqrt(e2)/config.params.eps, acc[0]))
if __name__ == "__main__":
config.update(
{'Re': 8000.,
'nu': 1./8000., # Viscosity
'dt': 0.001, # Time step
'T': 0.01, # End time
'L': [2*pi, pi, 2],
'M': [5, 2, 7],
'Dquad': 'GC',
'Bquad': 'GC',
'dealias': None
}, "channel"
)
config.channel.add_argument("--compute_energy", type=int, default=1)
config.channel.add_argument("--plot_step", type=int, default=1)
config.channel.add_argument("--refinement_test", type=bool, default=False)
config.channel.add_argument("--eps_refinement_test", type=bool, default=False)
config.channel.add_argument("--spatial_refinement_test", type=bool, default=False)
config.channel.add_argument("--eps", type=float, default=1e-7)
#solver = get_solver(update=update, regression_test=regression_test, mesh="channel")
solver = get_solver(update=update, mesh="channel")
if config.params.eps_refinement_test:
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)
self.fname = filename
self.f0 = h5py.File(filename+".h5", "a", driver="mpio", comm=self.comm)
N = self.shape[0]
s = slice(self.rank*N, (self.rank+1)*N, 1)
for i, name in enumerate(("U", "V", "W")):
self.Umean[i, :] = self.f0["Average/"+name][s]
self.Pmean[:] = self.f0["Average/P"][s]
for i, name in enumerate(("UU", "VV", "WW", "UV", "UW", "VW")):
self.UU[i, :] = self.f0["Reynolds Stress/"+name][s]
if __name__ == "__main__":
config.update(
{
'nu': 1./590., # Viscosity
'Re_tau': 590.,
'dt': 0.001, # Time step
'T': 100., # End time
'L': [2, 2*pi, pi],
'M': [6, 6, 5]
}, "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")
initialize(**vars(solver))
#init_from_file("KMM666.h5", **vars(solver))
set_Source(**vars(solver))
solver.stats = Stats(solver.U, solver.comm, filename="KMMstats")
solver.hdf5file.fname = "KMM666d.h5"
solver.solve()
# Set g, which is used in computing convection
context.g[:] = 1j*context.K[1]*U_hat[2] - 1j*context.K[2]*U_hat[1]
context.U_hat0[:] = U_hat
context.H_hat1[:] = solver.get_convection(**context)
# 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./590., # Viscosity
'Re_tau': 590.,
'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")
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)
def spatial_refinement_test(context):
_, e2, _ = compute_error(context)
if config.solver.rank == 0:
print(r" %2d & %2.8e & %2.8e \\\ " %
(2**config.params.M[0], sqrt(e2) / config.params.eps, acc[0]))
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, pi],
'M': [7, 5, 2],
'Dquad': 'GC',
'Bquad': 'GC',
'dealias': None
},
"channel")
config.channel.add_argument("--compute_energy", type=int, default=1)
config.channel.add_argument("--plot_step", type=int, default=1)
config.channel.add_argument("--refinement_test", type=bool, default=False)
config.channel.add_argument("--eps_refinement_test",
type=bool,
default=False)
config.channel.add_argument("--spatial_refinement_test",
type=bool,
default=False)
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.decomposition == 'slab'
context = solver.get_context()
Nd = self.num_samples * self.shape[1] * self.shape[2]
s = slice(self.rank * N, (self.rank + 1) * N, 1)
for i, name in enumerate(("U", "V", "W")):
self.Umean[i, :] = self.f0["Average/" + name][s] * Nd
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")
# Set g, which is used in computing convection
context.g[:] = 1j*context.K[1]*U_hat[2] - 1j*context.K[2]*U_hat[1]
context.U_hat0[:] = U_hat
context.H_hat1[:] = solver.get_convection(**context)
# 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.W_hat = solver.cross2(context.W_hat, context.K, context.U_hat)
context.target_energy = energy_fourier(solver.comm, U_hat)
f.close()
if __name__ == "__main__":
import h5py
config.update(
{
'nu': 0.005428, # Viscosity (not used, see below)
'dt': 0.002, # Time step
'T': 5, # End time
'L': [2. * pi, 2. * pi, 2. * pi],
'checkpoint': 100,
'write_result': 1e8,
#'decomposition': 'pencil',
#'Pencil_alignment': 'Y',
#'P1': 2
},
"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,
curl = solver.get_curl(**context)
w = solver.comm.reduce(sum(curl.astype(float64)*curl.astype(float64))*dx[0]*dx[1]*dx[2]/L[0]/L[1]/L[2]/2)
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
config.solver.MemoryUsage('End', context.FFT.comm)
if solver.rank == 0:
assert round(w - 0.375249930801, params.ntol) == 0
assert round(k - 0.124953117517, params.ntol) == 0
if __name__ == "__main__":
config.update(
{
'nu': 0.000625, # Viscosity
'dt': 0.01, # Time step
'T': 0.1, # End time
'L': [2*pi, 0.5*pi, 2*pi],
'M': [5, 5, 5],
#'planner_effort': {'dct': 'FFTW_EXHAUSTIVE'},
#'decomposition': 'pencil',
#'Pencil_alignment': 'Y',
#'P1': 2
}, "triplyperiodic"
)
config.triplyperiodic.add_argument("--compute_energy", type=int, default=2)
config.triplyperiodic.add_argument("--plot_step", type=int, default=2)
sol = get_solver(update=update, regression_test=regression_test,
mesh="triplyperiodic")
context = sol.get_context()
# Add curl to the stored results. For this we need to update the update_components
# method used by the HDF5Writer class to compute the real fields that are stored
if 'VV' in config.params.solver:
context.W_hat = solver.cross2(context.W_hat, context.K, context.U_hat)
context.target_energy = energy_fourier(solver.comm, U_hat)
f.close()
if __name__ == "__main__":
import h5py
config.update(
{'nu': 0.005428, # Viscosity (not used, see below)
'dt': 0.002, # Time step
'T': 5, # End time
'L': [2.*pi, 2.*pi, 2.*pi],
'checkpoint': 100,
'write_result': 1e8,
}, "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.))
# current timestep
U_hat[:] = f["U/3D/0"][su]
if hasattr(context, 'g'):
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, 5],
'dealias': '3/2-rule',
'checkpoint': 2000,
},
"channel")
config.channel.add_argument("--compute_energy", type=int, default=100)
config.channel.add_argument("--plot_result", type=int, default=200)
config.channel.add_argument("--sample_stats", type=int, default=200)
config.channel.add_argument("--print_energy0", type=int, default=1000)
#solver = get_solver(update=update, mesh="channel")
solver = get_solver(update=update, mesh="channel")
context = solver.get_context()
#initialize(solver, context)
init_from_file("KMM776d_c.h5", solver, context)
set_Source(**context)
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__":
from numpy import allclose, random
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],
#'decomposition': 'pencil',
#'Pencil_alignment': 'Y',
#'P1': 2
},
"triplyperiodic")
config.triplyperiodic.add_argument("--compute_energy", type=int, default=2)
config.triplyperiodic.add_argument("--plot_step", type=int, default=10)
solver = get_solver(update=update, mesh="triplyperiodic")
solver.hdf5file.fname = "NS7.h5"
solver.hdf5file.components["W0"] = solver.curl[0]
solver.hdf5file.components["W1"] = solver.curl[1]
solver.hdf5file.components["W2"] = solver.curl[2]
initialize(**vars(solver))
solver.solve()
if rank == 0:
print "Time %2.5f Error %2.12e" % (
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))
if solver.rank == 0:
assert round(asscalar(w) - 0.375249930801, params.ntol) == 0
assert round(asscalar(k) - 0.124953117517, params.ntol) == 0
if __name__ == "__main__":
Re = 1e4
U = 2**(1. / 3)
L = 1.
dt = 1e-12
config.update(
{
'nu': U * L / Re, # Viscosity
'dt': dt, # Time step
'T': 11 * dt, # End time
'L': [L, L, L],
'M': [7, 7, 7], # Mesh size is pow(2, M[i]) in direction i
#'planner_effort': {'fft': 'FFTW_EXHAUSTIVE'},
#'decomposition': 'pencil',
#'P1': 2
},
"triplyperiodic")
config.triplyperiodic.add_argument("--compute_energy", type=int, default=2)
config.triplyperiodic.add_argument("--plot_step", type=int, default=2)
if plt is None:
sol = get_solver(mesh="triplyperiodic")
else:
sol = get_solver(update=update,
regression_test=regression_test,
mesh="triplyperiodic")
context = sol.get_context()
sum(U.astype(float64) * U.astype(float64)) / prod(params.N) /
2) # Compute energy with double precision
config.solver.MemoryUsage('End')
if solver.rank == 0:
assert round(w.item() - 0.375249930801, params.ntol) == 0, w
assert round(k.item() - 0.124953117517, params.ntol) == 0, k
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],
'planner_effort': {
'fft': 'FFTW_ESTIMATE',
'rfftn': 'FFTW_ESTIMATE',
'irfftn': 'FFTW_ESTIMATE'
},
},
"triplyperiodic")
config.triplyperiodic.add_argument("--compute_energy", type=int, default=2)
config.triplyperiodic.add_argument("--plot_step", type=int, default=2)
config.triplyperiodic.add_argument("--N",
default=[32, 32, 32],
nargs=3,
help="Mesh size. Trumps M.")
sol = get_solver(update=update,
regression_test=regression_test,
mesh="triplyperiodic")
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))
im.set_data(P[:, :].T)
im.autoscale()
plt.pause(1e-6)
im2.set_data(curl[:,:].T)
im2.autoscale()
plt.pause(1e-6)
if rank == 0:
print params.tstep
if __name__ == "__main__":
config.update(
{
'nu': 1.0e-05,
'dt': 0.007,
'T': 25.0,
'U1':-0.5,
'U2':0.5,
'l0': 0.001, # Smoothing parameter
'A': 0.01, # Amplitude of perturbation
'delta': 0.1, # Width of perturbations
'write_result': 500
}, 'doublyperiodic'
)
# Adding new arguments required here to allow overloading through commandline
config.doublyperiodic.add_argument('--plot_result', type=int, default=10)
config.doublyperiodic.add_argument('--compute_energy', type=int, default=10)
solver = get_solver(update, mesh='doublyperiodic')
assert config.params.solver == 'NS2D'
initialize(**vars(solver))
solver.solve()
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()
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)
im2.autoscale()
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)
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)
**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()
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)
solver = config.solver
U = solver.get_velocity(**context)
curl = solver.get_curl(**context)
w = solver.comm.reduce(sum(curl.astype(float64)*curl.astype(float64))/prod(params.N)/2)
k = solver.comm.reduce(sum(U.astype(float64)*U.astype(float64))/prod(params.N)/2) # Compute energy with double precision
config.solver.MemoryUsage('End')
if solver.rank == 0:
assert round(w.item() - 0.375249930801, params.ntol) == 0, w
assert round(k.item() - 0.124953117517, params.ntol) == 0, k
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],
'planner_effort': {'fft': 'FFTW_ESTIMATE',
'rfftn': 'FFTW_ESTIMATE',
'irfftn': 'FFTW_ESTIMATE'},
}, "triplyperiodic")
config.triplyperiodic.add_argument("--compute_energy", type=int, default=2)
config.triplyperiodic.add_argument("--plot_step", type=int, default=2)
sol = get_solver(update=update, regression_test=regression_test,
mesh="triplyperiodic")
context = sol.get_context()
# Add curl to the stored results. For this we need to update the update_components
# method used by the HDF5File class to compute the real fields that are stored
context.hdf5file.filename = "NS9"
context.hdf5file.results['data'].update({'curl': [context.curl]})
