def check_error(params): error = np.zeros(N.size) for i in range(N.size): domain.N_p1 = int(N[i]) domain.N_p2 = int(N[i]) # Defining the physical system to be solved: system = physical_system(domain, boundary_conditions, params, initialize, advection_terms, collision_operator.BGK, moment_defs) # Declaring a linear system object which will evolve the defined physical system: nls = nonlinear_solver(system) N_g = nls.N_ghost_q # Time parameters: dt = 0.01 * 32 / nls.N_p1 t_final = 0.2 time_array = np.arange(dt, t_final + dt, dt) f_reference = nls.f for time_index, t0 in enumerate(time_array): nls.strang_timestep(dt) error[i] = af.mean(af.abs(nls.f - f_reference)) return (error)
def check_error(params): error = np.zeros(N.size) for i in range(N.size): domain.N_p1 = int(N[i]) domain.N_p2 = int(N[i]) # Defining the physical system to be solved: system = physical_system(domain, boundary_conditions, params, initialize, advection_terms, collision_operator.BGK, moment_defs) # Declaring a linear system object which will evolve the defined physical system: nls = nonlinear_solver(system) N_g = nls.N_ghost_q # Time parameters: dt = 0.01 * 32 / nls.N_p1 t_final = 0.2 time_array = np.arange(dt, t_final + dt, dt) # Since only the p = 1 mode is excited: E1 = nls.cell_centered_EM_fields_at_n[0] E2 = nls.cell_centered_EM_fields_at_n[1] E3 = nls.cell_centered_EM_fields_at_n[2] B1 = nls.cell_centered_EM_fields_at_n[3] B2 = nls.cell_centered_EM_fields_at_n[4] B3 = nls.cell_centered_EM_fields_at_n[5] (A_p1, A_p2, A_p3) = af.broadcast(nls._A_p, nls.q1_center, nls.q2_center, nls.p1_center, nls.p2_center, nls.p3_center, E1, E2, E3, B1, B2, B3, nls.physical_system.params) f_analytic = af.broadcast(initialize.initialize_f, nls.q1_center, nls.q2_center, addition(nls.p1_center, -A_p1 * t_final), addition(nls.p2_center, -A_p2 * t_final), nls.p3_center, nls.physical_system.params) for time_index, t0 in enumerate(time_array): nls.strang_timestep(dt) error[i] = af.mean(af.abs(nls.f - f_analytic)) return (error)
def check_error(params): error = np.zeros(N.size) for i in range(N.size): domain.N_p1 = int(N[i]) domain.N_p2 = int(N[i]) # Defining the physical system to be solved: system = physical_system(domain, boundary_conditions, params, initialize, advection_terms, collision_operator.BGK, moment_defs) # Declaring a linear system object which will evolve the defined physical system: nls = nonlinear_solver(system) N_g = nls.N_ghost_q # Time parameters: dt = 0.001 * 32 / nls.N_p1 t_final = 0.1 time_array = np.arange(dt, t_final + dt, dt) # Finding final resting point of the blob: E1 = nls.cell_centered_EM_fields[0] E2 = nls.cell_centered_EM_fields[1] B3 = nls.cell_centered_EM_fields[5] sol = odeint(dpdt, np.array([0, 0]), time_array, args=(af.mean(E1), af.mean(E2), af.mean(B3), params.charge_electron, params.mass_particle)) f_reference = af.broadcast(initialize.initialize_f, nls.q1_center, nls.q2_center, nls.p1_center - sol[-1, 0], nls.p2_center - sol[-1, 1], nls.p3_center, params) for time_index, t0 in enumerate(time_array): nls.strang_timestep(dt) error[i] = af.mean(af.abs(nls.f - f_reference)) return (error)
def check_error(params): error = np.zeros(N.size) for i in range(N.size): domain.N_q1 = int(N[i]) # Defining the physical system to be solved: system = physical_system(domain, boundary_conditions, params, initialize, advection_terms, collision_operator.BGK, moment_defs ) # Declaring a linear system object which will evolve the defined physical system: nls = nonlinear_solver(system) N_g = nls.N_ghost_q # Time parameters: dt = 0.01 * 32/nls.N_q1 t_final = 0.1 time_array = np.arange(dt, t_final + dt, dt) # Since only the p = 1 mode is excited: f_reference = af.broadcast(initialize.initialize_f, nls.q1_center - 1 * t_final, nls.q2_center, nls.p1_center, nls.p2_center, nls.p3_center, params ) for time_index, t0 in enumerate(time_array): nls.strang_timestep(dt) error[i] = af.mean(af.abs( nls.f[:, N_g:-N_g, N_g:-N_g] - f_reference[:, N_g:-N_g, N_g:-N_g] ) ) return(error)
import nonlinear_solver from bolt.lib.nonlinear_solver.tests.performance.input_files \ import domain from bolt.lib.nonlinear_solver.tests.performance.input_files \ import boundary_conditions from bolt.lib.nonlinear_solver.tests.performance.input_files \ import params from bolt.lib.nonlinear_solver.tests.performance.input_files \ import initialize import bolt.src.nonrelativistic_boltzmann.advection_terms as advection_terms import bolt.src.nonrelativistic_boltzmann.collision_operator \ as collision_operator import bolt.src.nonrelativistic_boltzmann.moment_defs as moment_defs # Defining the physical system to be solved: system = physical_system(domain, boundary_conditions, params, initialize, advection_terms, collision_operator.BGK, moment_defs) # Defining a nonlinear solver object: nls = nonlinear_solver(system, True) nls.strang_timestep(0.001) af.sync() for i in range(100): nls.strang_timestep(0.001) af.sync() nls.print_performance_timings(101)
pl.rcParams['xtick.direction'] = 'in' pl.rcParams['ytick.major.size'] = 8 pl.rcParams['ytick.minor.size'] = 4 pl.rcParams['ytick.major.pad'] = 8 pl.rcParams['ytick.minor.pad'] = 8 pl.rcParams['ytick.color'] = 'k' pl.rcParams['ytick.labelsize'] = 'medium' pl.rcParams['ytick.direction'] = 'in' # Defining the physical system to be solved: system = physical_system(domain, boundary_conditions, params, initialize, advection_terms, collision_operator.BGK, moment_defs) # Declaring a linear system object which will evolve the defined physical system: nls = nonlinear_solver(system) # Time parameters: dt = 0.0005 t_final = 2.0 time_array = np.arange(0, t_final + dt, dt) temp_data_nls = np.zeros_like(time_array) n_nls = nls.compute_moments('density') p1_bulk_nls = nls.compute_moments('mom_p1_bulk') / n_nls p2_bulk_nls = nls.compute_moments('mom_p2_bulk') / n_nls p3_bulk_nls = nls.compute_moments('mom_p3_bulk') / n_nls T_nls = (nls.compute_moments('energy') - n_nls * p1_bulk_nls**2 -
def test_shear_y(): t = np.random.rand(1)[0] N = 2**np.arange(5, 10) error = np.zeros(N.size) for i in range(N.size): domain.N_q1 = int(N[i]) domain.N_q2 = int(N[i]) # Defining the physical system to be solved: system = physical_system(domain, boundary_conditions_y, params, initialize_y, advection_terms, collision_operator.BGK, moment_defs) L_q1 = domain.q1_end - domain.q1_start L_q2 = domain.q2_end - domain.q2_start nls = nonlinear_solver(system) N_g = nls.N_ghost_q # For left: f_reference_bot = af.broadcast( initialize_y.initialize_f, af.select( nls.q1_center - t < domain.q1_start, # Periodic domain nls.q1_center - t + L_q1, nls.q1_center - t), nls.q2_center, nls.p1_center, nls.p2_center, nls.p3_center, params)[:, N_g:-N_g, -2 * N_g:-N_g] # For right: f_reference_top = af.broadcast( initialize_y.initialize_f, af.select(nls.q1_center + t > domain.q1_end, nls.q1_center + t - L_q1, nls.q1_center + t), nls.q2_center, nls.p1_center, nls.p2_center, nls.p3_center, params)[:, N_g:-N_g, N_g:2 * N_g] nls.time_elapsed = t nls._communicate_f() nls._apply_bcs_f() error[i] = af.mean(af.abs(nls.f[:, N_g:-N_g, :N_g] - f_reference_bot)) \ + af.mean(af.abs(nls.f[:, N_g:-N_g, -N_g:] - f_reference_top)) pl.loglog(N, error, '-o', label='Numerical') pl.loglog(N, error[0] * 32**3 / N**3, '--', color='black', label=r'$O(N^{-3})$') pl.xlabel(r'$N$') pl.ylabel('Error') pl.legend() pl.savefig('plot2.png') poly = np.polyfit(np.log10(N), np.log10(error), 1) assert (abs(poly[0] + 3) < 0.3)
def run_cases(q_dim, p_dim, charge_electron, tau): params.charge_electron = charge_electron params.tau = tau # Running the setup for all resolutions: for i in range(N.size): af.device_gc() domain.N_q1 = int(N[i]) if (q_dim == 2): domain.N_q2 = int(N[i]) params.k_q2 = 4 * np.pi if (p_dim == 2): domain.N_p2 = 32 domain.p2_start = -10 domain.p2_end = 10 if (p_dim == 3): domain.N_p3 = 32 domain.p3_start = -10 domain.p3_end = 10 if (charge_electron != 0): domain.N_p1 = int(N[i]) if (p_dim == 2): domain.N_p2 = int(N[i]) if (p_dim == 3): domain.N_p3 = int(N[i]) params.p_dim = p_dim dt = 1e-3 / (2**i) # Defining the physical system to be solved: system = physical_system(domain, boundary_conditions, params, initialize, advection_terms, collision_operator.BGK, moment_defs) linearized_system = physical_system(domain, boundary_conditions, params, initialize, advection_terms, collision_operator.linearized_BGK, moment_defs) # Declaring a linear system object which will # evolve the defined physical system: nls = nonlinear_solver(system) ls = linear_solver(system) time_array = np.arange(dt, t_final + dt, dt) for time_index, t0 in enumerate(time_array): print(t0) nls.strang_timestep(dt) ls.RK4_timestep(dt) nls.dump_distribution_function('dump_files/nlsf_' + str(N[i])) ls.dump_distribution_function('dump_files/lsf_' + str(N[i]))