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