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]})