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