def test_regular_3D(backend, forward_output):
if (backend == 'netcdf4' and forward_output is True) or skip[backend]:
return
K0 = Basis(N[0], 'F', dtype='D', domain=(0, np.pi))
K1 = Basis(N[1], 'F', dtype='d', domain=(0, 2*np.pi))
K2 = Basis(N[2], 'C', dtype='d', bc=(0, 0))
T = TensorProductSpace(comm, (K0, K1, K2))
filename = 'test3Dr_{}'.format(ex[forward_output])
hfile = writer(filename, T, backend=backend)
if forward_output:
u = Function(T)
else:
u = Array(T)
u[:] = np.random.random(u.shape)
for i in range(3):
hfile.write(i, {'u': [u,
(u, [slice(None), 4, slice(None)]),
(u, [slice(None), 4, 4])]}, forward_output=forward_output)
if not forward_output and backend == 'hdf5' and comm.Get_rank() == 0:
generate_xdmf(filename+'.h5')
u0 = Function(T) if forward_output else Array(T)
read = reader(filename, T, backend=backend)
read.read(u0, 'u', forward_output=forward_output, step=1)
assert np.allclose(u0, u)
def test_mixed_3D(backend, forward_output, as_scalar):
if (backend == 'netcdf4' and forward_output is True) or skip[backend]:
return
K0 = Basis(N[0], 'F', dtype='D', domain=(0, np.pi))
K1 = Basis(N[1], 'F', dtype='d', domain=(0, 2*np.pi))
K2 = Basis(N[2], 'C')
T = TensorProductSpace(comm, (K0, K1, K2))
TT = VectorTensorProductSpace(T)
filename = 'test3Dm_{}'.format(ex[forward_output])
hfile = writer(filename, TT, backend=backend)
uf = Function(TT, val=2) if forward_output else Array(TT, val=2)
uf[0] = 1
data = {'ux': ((uf, np.s_[0, :, :, :]),
(uf, [0, slice(None), 4, slice(None)]),
(uf, [0, slice(None), 4, 4])),
'uy': ((uf, np.s_[1, :, :, :]),
(uf, [1, slice(None), 4, slice(None)]),
(uf, [1, slice(None), 4, 4])),
'u': [uf, (uf, [slice(None), slice(None), 4, slice(None)])]}
hfile.write(0, data, forward_output=forward_output, as_scalar=as_scalar)
hfile.write(1, data, forward_output=forward_output, as_scalar=as_scalar)
if not forward_output and backend == 'hdf5' and comm.Get_rank() == 0:
generate_xdmf(filename+'.h5')
if as_scalar is False:
u0 = Function(TT) if forward_output else Array(TT)
read = reader(filename, TT, backend=backend)
read.read(u0, 'u', forward_output=forward_output, step=1)
assert np.allclose(u0, uf)
else:
u0 = Function(T) if forward_output else Array(T)
read = reader(filename, T, backend=backend)
read.read(u0, 'u0', forward_output=forward_output, step=1)
assert np.allclose(u0, uf[0])
def test_mixed_2D(backend, forward_output, as_scalar):
if (backend == 'netcdf4' and forward_output is True) or skip[backend]:
return
K0 = Basis(N[0], 'F')
K1 = Basis(N[1], 'C')
T = TensorProductSpace(comm, (K0, K1))
TT = MixedTensorProductSpace([T, T])
filename = 'test2Dm_{}'.format(ex[forward_output])
hfile = writer(filename, TT, backend=backend)
if forward_output:
uf = Function(TT, val=2)
else:
uf = Array(TT, val=2)
hfile.write(0, {'uf': [uf]}, forward_output=forward_output, as_scalar=as_scalar)
hfile.write(1, {'uf': [uf]}, forward_output=forward_output, as_scalar=as_scalar)
if not forward_output and backend == 'hdf5' and comm.Get_rank() == 0:
generate_xdmf(filename+'.h5')
if as_scalar is False:
u0 = Function(TT) if forward_output else Array(TT)
read = reader(filename, TT, backend=backend)
read.read(u0, 'uf', forward_output=forward_output, step=1)
assert np.allclose(u0, uf)
else:
u0 = Function(T) if forward_output else Array(T)
read = reader(filename, T, backend=backend)
read.read(u0, 'uf0', forward_output=forward_output, step=1)
assert np.allclose(u0, uf[0])
def test_2D(backend, forward_output):
if backend == 'netcdf4':
assert forward_output is False
T = PFFT(comm, (N[0], N[1]))
for i, domain in enumerate([
None, ((0, np.pi), (0, 2 * np.pi)),
(np.arange(N[0], dtype=float) * 1 * np.pi / N[0],
np.arange(N[1], dtype=float) * 2 * np.pi / N[1])
]):
for rank in range(3):
filename = "".join(
('test2D_{}{}{}'.format(ex[i == 0], ex[forward_output],
rank), ending[backend]))
if backend == 'netcdf4':
remove_if_exists(filename)
u = newDistArray(T,
forward_output=forward_output,
val=1,
rank=rank)
hfile = writer[backend](filename, domain=domain)
assert hfile.backend() == backend
hfile.write(0, {'u': [u]})
hfile.write(1, {'u': [u]})
u.write(hfile, 'u', 2)
if rank > 0:
hfile.write(0, {'u': [u]}, as_scalar=True)
hfile.write(1, {'u': [u]}, as_scalar=True)
u.write(hfile, 'u', 2, as_scalar=True)
u.write('t' + filename, 'u', 0)
u.write('t' + filename, 'u', 0, [slice(None), 3])
if not forward_output and backend == 'hdf5' and comm.Get_rank(
) == 0:
generate_xdmf(filename)
generate_xdmf(filename, order='visit')
u0 = newDistArray(T, forward_output=forward_output, rank=rank)
read = reader[backend](filename)
read.read(u0, 'u', step=0)
u0.read(filename, 'u', 2)
u0.read(read, 'u', 2)
assert np.allclose(u0, u)
if backend == 'netcdf4': # Test opening file in mode 'a' when not existing
remove_if_exists('nctesta.nc')
_ = NCFile('nctesta.nc', domain=domain, mode='a')
T.destroy()
def test_regular_2D(backend, forward_output):
if (backend == 'netcdf4' and forward_output is True) or skip[backend]:
return
K0 = Basis(N[0], 'F')
K1 = Basis(N[1], 'C', bc=(0, 0))
T = TensorProductSpace(comm, (K0, K1))
filename = 'test2Dr_{}'.format(ex[forward_output])
hfile = writer(filename, T, backend=backend)
u = Function(T, val=1) if forward_output else Array(T, val=1)
hfile.write(0, {'u': [u]}, forward_output=forward_output)
hfile.write(1, {'u': [u]}, forward_output=forward_output)
if not forward_output and backend == 'hdf5' and comm.Get_rank() == 0:
generate_xdmf(filename+'.h5')
generate_xdmf(filename+'.h5', order='visit')
u0 = Function(T) if forward_output else Array(T)
read = reader(filename, T, backend=backend)
read.read(u0, 'u', forward_output=forward_output, step=1)
assert np.allclose(u0, u)
def test_4D(backend, forward_output):
if backend == 'netcdf4':
assert forward_output is False
T = PFFT(comm, (N[0], N[1], N[2], N[3]))
d0 = ((0, np.pi), (0, 2 * np.pi), (0, 3 * np.pi), (0, 4 * np.pi))
d1 = (np.arange(N[0], dtype=float) * 1 * np.pi / N[0],
np.arange(N[1], dtype=float) * 2 * np.pi / N[1],
np.arange(N[2], dtype=float) * 3 * np.pi / N[2],
np.arange(N[3], dtype=float) * 4 * np.pi / N[3])
for i, domain in enumerate([None, d0, d1]):
for rank in range(3):
filename = "".join(
('h5test4_{}{}{}'.format(ex[i == 0], ex[forward_output],
rank), ending[backend]))
if backend == 'netcdf4':
remove_if_exists('uv' + filename)
u = newDistArray(T, forward_output=forward_output, rank=rank)
v = newDistArray(T, forward_output=forward_output, rank=rank)
h0file = writer[backend]('uv' + filename, domain=domain)
u[:] = np.random.random(u.shape)
v[:] = 2
for k in range(3):
h0file.write(
k, {
'u':
[u, (u, [slice(None), 4,
slice(None),
slice(None)])],
'v': [v,
(v, [slice(None), slice(None), 5, 6])]
})
if not forward_output and backend == 'hdf5' and comm.Get_rank(
) == 0:
generate_xdmf('uv' + filename)
u0 = newDistArray(T, forward_output=forward_output, rank=rank)
read = reader[backend]('uv' + filename)
read.read(u0, 'u', step=0)
assert np.allclose(u0, u)
read.read(u0, 'v', step=0)
assert np.allclose(u0, v)
T.destroy()
},
as_scalar=True)
file_v.write(tstep, {
'U': [
U, (U, [4, slice(None), slice(None)]),
(U, [4, slice(None), slice(None)]),
(U, [0, slice(None), slice(None)]), (U, [5, 5, slice(None)])
],
'u': [u]
},
as_scalar=False) # A scalar in the vector component space T
tstep += 1
if backend == 'hdf5' and MPI.COMM_WORLD.Get_rank() == 0:
generate_xdmf('myfile.h5')
generate_xdmf('mixfile.h5')
generate_xdmf('vecfile.h5')
N = (8, 24, 25, 26)
K0 = FunctionSpace(N[0], 'F', dtype='D')
K1 = FunctionSpace(N[1], 'F', dtype='D')
K2 = FunctionSpace(N[2], 'F', dtype='D')
K3 = FunctionSpace(N[3], 'F', dtype='d')
T = TensorProductSpace(MPI.COMM_WORLD, (K0, K1, K2, K3))
TT = CompositeSpace([T, T])
d4file_s = ShenfunFile('my4Dfile', T, backend=backend, mode='w')
d4file_m = ShenfunFile('mix4Dfile', TT, backend=backend, mode='w')
u = Array(T)
'write_slice_tstep': (10, {
'fu': [(fu, [slice(None),
slice(None), 10,
slice(None)]),
(fu, [slice(None), 10,
slice(None),
slice(None)])]
}),
'write_tstep': (50, {
'fu': [fu]
}),
'Compute_energy':
100,
'plot_tstep':
100,
'end_time':
100.,
'file':
file0
}
dt = 0.005
integrator = ETDRK4(TT, N=NonlinearRHS, update=update, **par)
#integrator = RK4(TT, N=NonlinearRHS, update=update)
integrator.setup(dt)
t0 = time()
fu_hat = integrator.solve(fu, fu_hat, dt, (0, par['end_time']))
timer.final(True)
if rank == 0:
generate_xdmf("KleinGordon{}.h5".format(N[0]))
image.ax.clear()
image.ax.contourf(X[0], X[1], uv[0].real, 100)
plt.pause(1e-6)
print(np.linalg.norm(uv[0] - uv0[0]), np.linalg.norm(uv[1] - uv0[1]),
np.linalg.norm(uv[0]), np.linalg.norm(uv[1]))
uv0[:] = uv
if tstep % params['write_tstep'][0] == 0:
uv = uv_hat.backward(uv)
params['file'].write(tstep, params['write_tstep'][1], as_scalar=True)
if __name__ == '__main__':
file0 = HDF5File("Gray_Scott_{}.h5".format(N[0]), mode='w')
par = {
'plot_step': 200,
'write_tstep': (200, {
'uv': [UV]
}),
'file': file0,
'kappa': 0.061,
'alpha1': 1.5,
'alpha2': 1.9
}
dt = 10.
end_time = 1000000
integrator = ETDRK4(TV, L=LinearRHS, N=NonlinearRHS, update=update, **par)
integrator.setup(dt)
UV_hat = integrator.solve(UV, UV_hat, dt, (0, end_time))
generate_xdmf("Gray_Scott_{}.h5".format(N[0]))
rhs[0] = self.w1
rhs.mask_nyquist(self.mask)
return rhs
if __name__ == '__main__':
from time import time
from mpi4py_fft import generate_xdmf
t0 = time()
d = {
'N': (100, 256),
'Ra': 10000.,
'dt': 0.02,
'filename': 'RB100',
'conv': 1,
'modplot': 100,
'modsave': 50,
'bcT': (0.9 + 0.1 * sympy.sin(2 * (y - tt)), 0),
#'bcT': (1, 0),
'family': 'C',
'quad': 'GC'
}
c = RayleighBenard(**d)
c.initialize(rand=0.0001)
c.assemble()
c.solve(end_time=200)
print('Computing time %2.4f' % (time() - t0))
if comm.Get_rank() == 0:
generate_xdmf('_'.join((d['filename'], 'U')) + '.h5')
generate_xdmf('_'.join((d['filename'], 'T')) + '.h5')
if tstep % plot_tstep == 0 and plot_tstep > 0:
u = u_hat.backward(u)
image.ax.clear()
image.ax.contourf(X[0], X[1], u.real, 100)
plt.pause(1e-6)
count += 1
#plt.savefig('Ginzburg_Landau_{}_{}.png'.format(N[0], count))
if tstep % write_tstep[0] == 0:
u = u_hat.backward(u)
file.write(tstep, write_tstep[1])
if __name__ == '__main__':
file0 = HDF5File("Ginzburg_Landau_{}.h5".format(N[0]), mode='w')
par = {
'plot_tstep': 100,
'write_tstep': (50, {
'u': [U.real]
}),
'file': file0
}
t = 0.0
dt = 0.01
end_time = 100
integrator = ETDRK4(T, L=LinearRHS, N=NonlinearRHS, update=update, **par)
integrator.setup(dt)
U_hat = integrator.solve(U, U_hat, dt, (0, end_time))
if comm.Get_rank() == 0:
generate_xdmf("Ginzburg_Landau_{}.h5".format(N[0]))
fftw.export_wisdom('GL.wisdom')
def test_3D(backend, forward_output):
if backend == 'netcdf4':
assert forward_output is False
T = PFFT(comm, (N[0], N[1], N[2]))
d0 = ((0, np.pi), (0, 2 * np.pi), (0, 3 * np.pi))
d1 = (np.arange(N[0], dtype=float) * 1 * np.pi / N[0],
np.arange(N[1], dtype=float) * 2 * np.pi / N[1],
np.arange(N[2], dtype=float) * 3 * np.pi / N[2])
for i, domain in enumerate([None, d0, d1]):
for rank in range(3):
filename = ''.join(
('test_{}{}{}'.format(ex[i == 0], ex[forward_output],
rank), ending[backend]))
if backend == 'netcdf4':
remove_if_exists('uv' + filename)
remove_if_exists('v' + filename)
u = newDistArray(T, forward_output=forward_output, rank=rank)
v = newDistArray(T, forward_output=forward_output, rank=rank)
h0file = writer[backend]('uv' + filename, domain=domain)
h1file = writer[backend]('v' + filename, domain=domain)
u[:] = np.random.random(u.shape)
v[:] = 2
for k in range(3):
h0file.write(
k, {
'u': [
u, (u, [slice(None), slice(None), 4]),
(u, [5, 5, slice(None)])
],
'v': [v,
(v, [slice(None), 6, slice(None)])]
})
h1file.write(
k, {
'v': [
v,
(v, [slice(None), 6, slice(None)]),
(v, [6, 6, slice(None)])
]
})
# One more time with same k
h0file.write(
k, {
'u': [
u, (u, [slice(None), slice(None), 4]),
(u, [5, 5, slice(None)])
],
'v': [v, (v, [slice(None), 6, slice(None)])]
})
h1file.write(
k, {
'v': [
v, (v, [slice(None), 6, slice(None)]),
(v, [6, 6, slice(None)])
]
})
if rank > 0:
for k in range(3):
u.write('uv' + filename, 'u', k, as_scalar=True)
u.write('uv' + filename,
'u',
k, [slice(None), slice(None), 4],
as_scalar=True)
u.write('uv' + filename,
'u',
k, [5, 5, slice(None)],
as_scalar=True)
v.write('uv' + filename, 'v', k, as_scalar=True)
v.write('uv' + filename,
'v',
k, [slice(None), 6, slice(None)],
as_scalar=True)
if not forward_output and backend == 'hdf5' and comm.Get_rank(
) == 0:
generate_xdmf('uv' + filename)
generate_xdmf('v' + filename, periodic=False)
generate_xdmf('v' + filename, periodic=(True, True, True))
generate_xdmf('v' + filename, order='visit')
u0 = newDistArray(T, forward_output=forward_output, rank=rank)
read = reader[backend]('uv' + filename)
read.read(u0, 'u', step=0)
assert np.allclose(u0, u)
read.read(u0, 'v', step=0)
assert np.allclose(u0, v)
T.destroy()
)
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"
# Just store slices
context.hdf5file.results['space'] = context.FST
context.hdf5file.results['data'] = {'U0': [(context.U[0], [slice(None), slice(None), 0]),
(context.U[0], [slice(None), 0, slice(None)])],
'U1': [(context.U[1], [slice(None), slice(None), 0]),
(context.U[1], [slice(None), 0, slice(None)])],
'U2': [(context.U[2], [slice(None), slice(None), 0]),
(context.U[2], [slice(None), 0, slice(None)])],
'phi': [(context.phi, [slice(None), slice(None), 0]),
(context.phi, [slice(None), 0, slice(None)])]
}
solver.stats = Stats(context.U, solver.comm, filename="KMM_RB_stats")
solve(solver, context)
if solver.rank == 0:
from mpi4py_fft import generate_xdmf
generate_xdmf('KMM_RB_677a_w.h5')
type=int,
default=100)
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_60_60_60_c.h5", sol, context)
context.hdf5file.filename = "NS_isotropic_{}_{}_{}".format(
*config.params.N)
Ek, bins, E0, E1, E2 = spectrum(sol, context)
context.spectrumname = context.hdf5file.filename + ".h5"
f = h5py.File(context.spectrumname, mode='w', driver='mpio', comm=sol.comm)
f.create_group("Turbulence")
f["Turbulence"].create_group("Ek")
bins = np.array(bins)
f["Turbulence"].create_dataset("bins", data=bins)
f.close()
solve(sol, context)
from mpi4py_fft import generate_xdmf
if sol.rank == 0:
generate_xdmf(context.hdf5file.filename + "_w.h5")
def write_xdmf_file(self, files):
if not isinstance(files, (list, tuple)):
generate_xdmf(files)
else:
for f in files:
generate_xdmf(f)
