def main():
filename_end = sys.argv[1]
check_laser(filename_end)
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename_end)
def check():
filename = sys.argv[1]
data_set_end = yt.load(filename)
sim_time = data_set_end.current_time.to_value()
#simulation results
all_data = data_set_end.all_data()
spec_names = [cc.name for cc in cases]
#All momenta
res_mom = np.array([
np.array([
all_data[sp, 'particle_momentum_x'].v[0],
all_data[sp, 'particle_momentum_y'].v[0],
all_data[sp, 'particle_momentum_z'].v[0]
]) for sp in spec_names
])
for cc in zip(cases, res_mom):
init_gamma = gamma(cc[0].init_mom)
end_gamma = gamma(cc[1] / m_e / c)
exp_gamma = exp_res(cc[0], sim_time)
error_rel = np.abs(end_gamma - exp_gamma) / exp_gamma
print("error_rel : " + str(error_rel))
print("tolerance_rel: " + str(tolerance_rel))
assert (error_rel < tolerance_rel)
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename)
def main():
print("Opening yt output")
filename_end = sys.argv[1]
data_set_end = yt.load(filename_end)
# get simulation time
sim_time = data_set_end.current_time.to_value()
# get particle data
all_data_end = data_set_end.all_data()
particle_data = {}
names, types = ac.get_all_species_names_and_types()
for spec_name_type in zip(names, types):
spec_name = spec_name_type[0]
is_photon = spec_name_type[1]
data = {}
data["px"] = all_data_end[spec_name,"particle_momentum_x"].v
data["py"] = all_data_end[spec_name,"particle_momentum_y"].v
data["pz"] = all_data_end[spec_name,"particle_momentum_z"].v
data["w"] = all_data_end[spec_name,"particle_weighting"].v
if is_photon :
data["opt"] = all_data_end[spec_name, "particle_opticalDepthBW"].v
else:
data["opt"] = all_data_end[spec_name, "particle_opticalDepthQSR"].v
particle_data[spec_name] = data
ac.check(sim_time, particle_data)
test_name = filename_end[:-9] # Could also be os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename_end)
def check():
filename = sys.argv[1]
data_set = yt.load(filename)
all_data = data_set.all_data()
res_ele_tau = all_data["electrons", 'particle_optical_depth_QSR']
res_pos_tau = all_data["positrons", 'particle_optical_depth_QSR']
loc_ele, scale_ele = st.expon.fit(res_ele_tau)
loc_pos, scale_pos = st.expon.fit(res_pos_tau)
# loc should be very close to 0, scale should be very close to 1
error_rel = np.abs(loc_ele - 0)
print("error_rel loc_ele: " + str(error_rel))
assert (error_rel < tolerance_rel)
error_rel = np.abs(loc_pos - 0)
print("error_rel loc_pos: " + str(error_rel))
assert (error_rel < tolerance_rel)
error_rel = np.abs(scale_ele - 1)
print("error_rel scale_ele: " + str(error_rel))
assert (error_rel < tolerance_rel)
error_rel = np.abs(scale_pos - 1)
print("error_rel scale_pos: " + str(error_rel))
assert (error_rel < tolerance_rel)
test_name = filename[:-9] # Could also be os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename)
def check():
filename_end = sys.argv[1]
data_set_end = yt.load(filename_end)
sim_time = data_set_end.current_time.to_value()
all_data_end = data_set_end.all_data()
for idx in range(4):
phot_name = spec_names_phot[idx]
ele_name = spec_names_ele[idx]
pos_name = spec_names_pos[idx]
p0 = initial_momenta[idx]
p2_phot = p0[0]**2 + p0[1]**2 + p0[2]**2
p_phot = np.sqrt(p2_phot)
energy_phot = p_phot * c
chi_phot = calc_chi_gamma(p0, E_f, B_f)
gamma_phot = np.linalg.norm(p0) / mec
print("** Case {:d} **".format(idx + 1))
print(" initial momentum: ", p0)
print(" quantum parameter: {:f}".format(chi_phot))
print(" normalized photon energy: {:f}".format(gamma_phot))
print(" timestep: {:f} fs".format(sim_time * 1e15))
phot_data = get_spec(all_data_end, phot_name, is_photon=True)
ele_data = get_spec(all_data_end, ele_name, is_photon=False)
pos_data = get_spec(all_data_end, pos_name, is_photon=False)
p2_ele = ele_data["px"]**2 + ele_data["py"]**2 + ele_data["pz"]**2
p_ele = np.sqrt(p2_ele)
energy_ele = np.sqrt(1.0 + p2_ele / mec**2) * mec2
p2_pos = pos_data["px"]**2 + pos_data["py"]**2 + pos_data["pz"]**2
p_pos = np.sqrt(p2_pos)
energy_pos = np.sqrt(1.0 + p2_pos / mec**2) * mec2
n_lost = check_number_of_pairs(data_set_end, phot_name, ele_name,
pos_name, chi_phot, gamma_phot,
sim_time, initial_particle_number)
check_weights(phot_data, ele_data, pos_data)
check_momenta(phot_data, ele_data, pos_data, p0, p_ele, p_pos)
check_energy(energy_phot, energy_ele, energy_pos)
check_energy_distrib(energy_ele, energy_pos, gamma_phot, chi_phot,
n_lost, NNS[idx], idx)
check_opt_depths(phot_data, ele_data, pos_data)
print("*************\n")
test_name = filename_end[:
-9] # Could also be os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename_end)
def check():
filename_end = sys.argv[1]
data_set_end = yt.load(filename_end)
sim_time = data_set_end.current_time.to_value()
# no particles can be created on the first timestep so we have 2 timesteps in the test case,
# with only the second one resulting in particle creation
dt = sim_time / 2.
all_data_end = data_set_end.all_data()
for idx in range(4):
part_name = spec_names[idx]
phot_name = spec_names_phot[idx]
t_pi = initial_momenta[idx]
pm = boris(t_pi, -dt * 0.5, csign[idx])
p0 = boris(pm, dt * 1.0, csign[idx])
p2_part = p0[0]**2 + p0[1]**2 + p0[2]**2
energy_part = np.sqrt(mec2**2 + p2_part * c**2)
gamma_part = energy_part / mec2
chi_part = calc_chi_part(p0, E_f, B_f)
print("** Case {:d} **".format(idx + 1))
print(" initial momentum: ", t_pi)
print(" quantum parameter: {:f}".format(chi_part))
print(" normalized particle energy: {:f}".format(gamma_part))
print(" timestep: {:f} fs".format(dt * 1e15))
part_data_final = get_spec(all_data_end, part_name, is_photon=False)
phot_data = get_spec(all_data_end, phot_name, is_photon=True)
p_phot = np.sqrt(phot_data["px"]**2 + phot_data["py"]**2 +
phot_data["pz"]**2)
energy_phot = p_phot * c
gamma_phot = energy_phot / mec2
n_phot = check_number_of_photons(data_set_end, part_name, phot_name,
chi_part, gamma_part, dt,
initial_particle_number)
check_weights(part_data_final, phot_data)
check_momenta(phot_data, p_phot, p0)
check_energy_distrib(gamma_phot, chi_part, gamma_part, n_phot,
NNS[idx], idx)
check_opt_depths(part_data_final, phot_data)
print("*************\n")
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename_end)
def check():
filename = sys.argv[1]
data_set_end = yt.load(filename)
sim_time = data_set_end.current_time.to_value()
#expected positions list
ll = sim_time * c
answ_pos = init_pos + \
ll*gamma_beta_list/np.linalg.norm(gamma_beta_list,axis=1, keepdims=True)
#expected momenta list
answ_mom = m_e * c * gamma_beta_list #momenta don't change
#simulation results
all_data = data_set_end.all_data()
res_pos = [
np.array([
all_data[sp, 'particle_position_x'].v[0],
all_data[sp, 'particle_position_y'].v[0],
all_data[sp, 'particle_position_z'].v[0]
]) for sp in spec_names
]
res_mom = [
np.array([
all_data[sp, 'particle_momentum_x'].v[0],
all_data[sp, 'particle_momentum_y'].v[0],
all_data[sp, 'particle_momentum_z'].v[0]
]) for sp in spec_names
]
#check discrepancies
disc_pos = [
np.linalg.norm(a - b) / np.linalg.norm(b)
for a, b in zip(res_pos, answ_pos)
]
disc_mom = [
np.linalg.norm(a - b) / np.linalg.norm(b)
for a, b in zip(res_mom, answ_mom)
]
print("max(disc_pos) = %s" % max(disc_pos))
print("tol_pos = %s" % tol_pos)
print("max(disc_mom) = %s" % max(disc_mom))
print("tol_mom = %s" % tol_mom)
assert ((max(disc_pos) <= tol_pos) and (max(disc_mom) <= tol_mom))
test_name = filename[:-9] # Could also be os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename)
def check():
filename_end = sys.argv[1]
data_set_end = yt.load(filename_end)
sim_time = data_set_end.current_time.to_value()
all_data_end = data_set_end.all_data()
for name in spec_names:
opt_depth = all_data_end[name, 'particle_optical_depth_BW']
#check that the distribution is still exponential with scale 1 and loc 0
opt_depth_loc, opt_depth_scale = st.expon.fit(opt_depth)
exp_loc = 0.0
exp_scale = 1.0
loc_discrepancy = np.abs(opt_depth_loc-exp_loc)
scale_discrepancy = np.abs(opt_depth_scale-exp_scale)
print("tolerance_rel: " + str(tol))
print("species " + name)
print("exp distrib loc tol = " + str(tol))
print("exp distrib loc discrepancy = " + str(loc_discrepancy))
assert(loc_discrepancy < tol)
print("exp distrib scale tol = " + str(tol))
print("exp distrib scale discrepancy = " + str(scale_discrepancy/exp_scale))
assert(scale_discrepancy/exp_scale < tol)
###
#check if number of lost photons is (n0* (1 - exp(-rate*t)) )
dNBW_dt_theo = dNBW_dt(
calc_chi_gamma(p_begin[name], E_f, B_f),
np.linalg.norm(p_begin[name]*speed_of_light))
exp_lost= initial_particle_number*(1.0 - np.exp(-dNBW_dt_theo*sim_time))
lost = initial_particle_number-np.size(opt_depth)
discrepancy_lost = np.abs(exp_lost-lost)
print("lost fraction tol = " + str(tol))
print("lost fraction discrepancy = " + str(discrepancy_lost/exp_lost))
assert(discrepancy_lost/exp_lost < tol)
###
test_name = filename_end[:-9] # Could also be os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename_end)
def main():
filename_end = sys.argv[1]
filename_start = filename_end[:-4] + '0000'
ds_end = yt.load(filename_end)
ds_start = yt.load(filename_start)
ad_end = ds_end.all_data()
ad_start = ds_start.all_data()
field_data_end = ds_end.covering_grid(level=0,
left_edge=ds_end.domain_left_edge,
dims=ds_end.domain_dimensions)
field_data_start = ds_start.covering_grid(
level=0,
left_edge=ds_start.domain_left_edge,
dims=ds_start.domain_dimensions)
ntests = 5
for i in range(1, ntests + 1):
proton_species = "proton" + str(i)
boron_species = "boron" + str(i)
alpha_species = "alpha" + str(i)
data = {}
add_species_to_dict(ad_start, data, proton_species, "proton", "start")
add_species_to_dict(ad_start, data, boron_species, "boron", "start")
add_species_to_dict(ad_end, data, proton_species, "proton", "end")
add_species_to_dict(ad_end, data, boron_species, "boron", "end")
add_species_to_dict(ad_end, data, alpha_species, "alpha", "end")
# General checks that are performed for all tests
generic_check(data)
# Checks that are specific to test number i
eval("specific_check" + str(i) + "(data)")
rho_start = field_data_start["rho"].to_ndarray()
rho_end = field_data_end["rho"].to_ndarray()
check_charge_conservation(rho_start, rho_end)
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename_end)
def check():
filename = sys.argv[1]
data_set = yt.load(filename)
all_data = data_set.all_data()
res_tau = all_data["photons", 'particle_optical_depth_BW']
loc, scale = st.expon.fit(res_tau)
# loc should be very close to 0, scale should be very close to 1
error_rel = np.abs(loc - 0)
print("error_rel for location: " + str(error_rel))
print("tolerance_rel: " + str(tolerance_rel))
assert (error_rel < tolerance_rel)
error_rel = np.abs(scale - 1)
print("error_rel for scale: " + str(error_rel))
print("tolerance_rel: " + str(tolerance_rel))
assert (error_rel < tolerance_rel)
test_name = filename[:-9] # Could also be os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename)
def main():
print("Opening yt output")
filename_end = sys.argv[1]
data_set_end = yt.load(filename_end)
# get simulation time
sim_time = data_set_end.current_time.to_value()
# no particles can be created on the first timestep so we have 2 timesteps in the test case,
# with only the second one resulting in particle creation
dt = sim_time/2.
# get particle data
all_data_end = data_set_end.all_data()
particle_data = {}
names, types = ac.get_all_species_names_and_types()
for spec_name_type in zip(names, types):
spec_name = spec_name_type[0]
is_photon = spec_name_type[1]
data = {}
data["px"] = all_data_end[spec_name,"particle_momentum_x"].v
data["py"] = all_data_end[spec_name,"particle_momentum_y"].v
data["pz"] = all_data_end[spec_name,"particle_momentum_z"].v
data["w"] = all_data_end[spec_name,"particle_weighting"].v
if is_photon :
data["opt"] = all_data_end[spec_name, "particle_opticalDepthBW"].v
else:
data["opt"] = all_data_end[spec_name, "particle_opticalDepthQSR"].v
particle_data[spec_name] = data
ac.check(dt, particle_data)
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename_end)
y = y0 * np.cos(-theta) - z0 * np.sin(-theta)
z = y0 * np.sin(-theta) + z0 * np.cos(-theta)
By = -2 / h_2 * mu_0 * (n * pi / Ly) * (p * pi / Lz) * (
np.cos(m * pi / Lx * (x - Lx / 2)) * np.sin(n * pi / Ly *
(y - Ly / 2)) *
np.cos(p * pi / Lz *
(z - Lz / 2)) * np.cos(np.sqrt(2) * np.pi / Lx * c * t))
Bz = mu_0 * (np.cos(m * pi / Lx * (x - Lx / 2)) *
np.cos(n * pi / Ly *
(y - Ly / 2)) * np.sin(p * pi / Lz *
(z - Lz / 2)) *
np.cos(np.sqrt(2) * np.pi / Lx * c * t))
Bz_th[i, j, k] = (By * np.sin(theta) +
Bz * np.cos(theta)) * (Bz_sim[i, j, k, 0] != 0)
# Compute relative l^2 error on By
rel_err_y = np.sqrt(
np.sum(np.square(By_sim[:, :, :, 0] - By_th)) / np.sum(np.square(By_th)))
assert (rel_err_y < rel_tol_err)
# Compute relative l^2 error on Bz
rel_err_z = np.sqrt(
np.sum(np.square(Bz_sim[:, :, :, 0] - Bz_th)) / np.sum(np.square(Bz_th)))
assert (rel_err_z < rel_tol_err)
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename)
#!/usr/bin/env python3 import os import sys sys.path.insert(1, '../../../../warpx/Regression/Checksum/') import checksumAPI # this will be the name of the plot file fn = sys.argv[1] # Get name of the test test_name = os.path.split(os.getcwd())[1] # Run checksum regression test checksumAPI.evaluate_checksum(test_name, fn, rtol=1e-2)
def do_analysis(single_precision=False):
fn = sys.argv[1]
ds = yt.load(fn)
ad = ds.all_data()
ad0 = ds.covering_grid(level=0,
left_edge=ds.domain_left_edge,
dims=ds.domain_dimensions)
#--------------------------------------------------------------------------------------------------
# Part 1: get results from plotfiles (label '_yt')
#--------------------------------------------------------------------------------------------------
# Quantities computed from plotfiles
values_yt = dict()
domain_size = ds.domain_right_edge.value - ds.domain_left_edge.value
dx = domain_size / ds.domain_dimensions
# Electrons
x = ad['electrons', 'particle_position_x'].to_ndarray()
y = ad['electrons', 'particle_position_y'].to_ndarray()
z = ad['electrons', 'particle_position_z'].to_ndarray()
uz = ad['electrons', 'particle_momentum_z'].to_ndarray() / m_e / c
w = ad['electrons', 'particle_weight'].to_ndarray()
x_ind = ((x - ds.domain_left_edge[0].value) / dx[0]).astype(int)
y_ind = ((y - ds.domain_left_edge[1].value) / dx[1]).astype(int)
z_ind = ((z - ds.domain_left_edge[2].value) / dx[2]).astype(int)
zavg = np.zeros(ds.domain_dimensions)
uzavg = np.zeros(ds.domain_dimensions)
zuzavg = np.zeros(ds.domain_dimensions)
wavg = np.zeros(ds.domain_dimensions)
for i_p in range(len(x)):
zavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * w[i_p]
uzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += uz[i_p] * w[i_p]
zuzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * uz[i_p] * w[i_p]
wavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += w[i_p]
wavg_adj = np.where(wavg == 0, 1, wavg)
values_yt['electrons: zavg'] = zavg / wavg_adj
values_yt['electrons: uzavg'] = uzavg / wavg_adj
values_yt['electrons: zuzavg'] = zuzavg / wavg_adj
# protons
x = ad['protons', 'particle_position_x'].to_ndarray()
y = ad['protons', 'particle_position_y'].to_ndarray()
z = ad['protons', 'particle_position_z'].to_ndarray()
uz = ad['protons', 'particle_momentum_z'].to_ndarray() / m_p / c
w = ad['protons', 'particle_weight'].to_ndarray()
x_ind = ((x - ds.domain_left_edge[0].value) / dx[0]).astype(int)
y_ind = ((y - ds.domain_left_edge[1].value) / dx[1]).astype(int)
z_ind = ((z - ds.domain_left_edge[2].value) / dx[2]).astype(int)
zavg = np.zeros(ds.domain_dimensions)
uzavg = np.zeros(ds.domain_dimensions)
zuzavg = np.zeros(ds.domain_dimensions)
wavg = np.zeros(ds.domain_dimensions)
for i_p in range(len(x)):
zavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * w[i_p]
uzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += uz[i_p] * w[i_p]
zuzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * uz[i_p] * w[i_p]
wavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += w[i_p]
wavg_adj = np.where(wavg == 0, 1, wavg)
values_yt['protons: zavg'] = zavg / wavg_adj
values_yt['protons: uzavg'] = uzavg / wavg_adj
values_yt['protons: zuzavg'] = zuzavg / wavg_adj
# Photons (momentum in units of m_e c)
x = ad['photons', 'particle_position_x'].to_ndarray()
y = ad['photons', 'particle_position_y'].to_ndarray()
z = ad['photons', 'particle_position_z'].to_ndarray()
uz = ad['photons', 'particle_momentum_z'].to_ndarray() / m_e / c
w = ad['photons', 'particle_weight'].to_ndarray()
x_ind = ((x - ds.domain_left_edge[0].value) / dx[0]).astype(int)
y_ind = ((y - ds.domain_left_edge[1].value) / dx[1]).astype(int)
z_ind = ((z - ds.domain_left_edge[2].value) / dx[2]).astype(int)
zavg = np.zeros(ds.domain_dimensions)
uzavg = np.zeros(ds.domain_dimensions)
zuzavg = np.zeros(ds.domain_dimensions)
wavg = np.zeros(ds.domain_dimensions)
for i_p in range(len(x)):
zavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * w[i_p]
uzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += uz[i_p] * w[i_p]
zuzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * uz[i_p] * w[i_p]
wavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += w[i_p]
wavg_adj = np.where(wavg == 0, 1, wavg)
values_yt['photons: zavg'] = zavg / wavg_adj
values_yt['photons: uzavg'] = uzavg / wavg_adj
values_yt['photons: zuzavg'] = zuzavg / wavg_adj
values_rd = dict()
# Load reduced particle diagnostic data from plotfiles
values_rd['electrons: zavg'] = ad0[('boxlib', 'z_electrons')]
values_rd['protons: zavg'] = ad0[('boxlib', 'z_protons')]
values_rd['photons: zavg'] = ad0[('boxlib', 'z_photons')]
values_rd['electrons: uzavg'] = ad0[('boxlib', 'uz_electrons')]
values_rd['protons: uzavg'] = ad0[('boxlib', 'uz_protons')]
values_rd['photons: uzavg'] = ad0[('boxlib', 'uz_photons')]
values_rd['electrons: zuzavg'] = ad0[('boxlib', 'zuz_electrons')]
values_rd['protons: zuzavg'] = ad0[('boxlib', 'zuz_protons')]
values_rd['photons: zuzavg'] = ad0[('boxlib', 'zuz_photons')]
#--------------------------------------------------------------------------------------------------
# Part 3: compare values from plotfiles and diagnostics and print output
#--------------------------------------------------------------------------------------------------
error = dict()
tolerance = 5e-3 if single_precision else 1e-12
for k in values_yt.keys():
# check that the zeros line up, since we'll be ignoring them in the error calculation
assert (np.all((values_yt[k] == 0) == (values_rd[k] == 0)))
error[k] = np.max(
abs(values_yt[k] - values_rd[k])[values_yt[k] != 0] /
abs(values_yt[k])[values_yt[k] != 0])
print(k, 'relative error = ', error[k])
assert (error[k] < tolerance)
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, fn)
#!/usr/bin/env python3
# Copyright 2021 Modern Electron
# This script checks that the PICMI_inputs_2d.py run more-or-less matches the
# results from the non-PICMI run. The PICMI run is using an external Poisson
# solver that directly solves the Poisson equation using matrix inversion
# rather than the iterative approach from the MLMG solver.
import sys
sys.path.append('../../../../warpx/Regression/Checksum/')
import checksumAPI
my_check = checksumAPI.evaluate_checksum(
'background_mcc', 'Python_background_mcc_plt00050',
do_particles=True, rtol=3.7e-3
)
error = error / nt
print('error = ', error)
print('tolerance = ', tolerance)
assert(error < tolerance)
## In the second past of the test, we verify that the diagnostic particle filter function works as
## expected. For this, we only use the last simulation timestep.
dim = "2d"
species_name = "electron"
parser_filter_fn = "diags/diag_parser_filter" + last_it
parser_filter_expression = "(x>200) * (z<200) * (px-3*pz>0)"
post_processing_utils.check_particle_filter(last_fn, parser_filter_fn, parser_filter_expression,
dim, species_name)
uniform_filter_fn = "diags/diag_uniform_filter" + last_it
uniform_filter_expression = "ids%6 == 0"
post_processing_utils.check_particle_filter(last_fn, uniform_filter_fn, uniform_filter_expression,
dim, species_name)
random_filter_fn = "diags/diag_random_filter" + last_it
random_fraction = 0.77
post_processing_utils.check_random_filter(last_fn, random_filter_fn, random_fraction,
dim, species_name)
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, fn, do_particles=False)
#!/usr/bin/env python3
import os
import re
import sys
sys.path.insert(1, '../../../../warpx/Regression/Checksum/')
import checksumAPI
# this will be the name of the plot file
fn = sys.argv[1]
# Get name of the test
test_name = os.path.split(os.getcwd())[1]
# Run checksum regression test
if re.search('single_precision', fn):
checksumAPI.evaluate_checksum(test_name, fn, rtol=2.e-6)
else:
checksumAPI.evaluate_checksum(test_name, fn)
#!/usr/bin/env python3
# Run the default regression test for the PICMI version of the EB test
# using the same reference file as for the non-PICMI test since the two
# tests are otherwise the same.
import sys
sys.path.append('../../../../warpx/Regression/Checksum/')
import checksumAPI
my_check = checksumAPI.evaluate_checksum(
'ElectrostaticSphereEB',
'Python_ElectrostaticSphereEB_plt000001',
do_particles=False,
atol=1e-12)
plt.title('Ex: Simulation')
plt.imshow(make_2d(Ex_array))
plt.colorbar()
plt.subplot(223)
plt.title('Ey: Theory')
plt.imshow(make_2d(Ey_th))
plt.colorbar()
plt.subplot(224)
plt.title('Ey: Simulation')
plt.imshow(make_2d(Ey_array))
plt.colorbar()
plt.savefig('Comparison.png')
# Automatically check the results
def check(E, E_th, label):
print('Relative error in %s: %.3f' %
(label, abs(E - E_th).max() / E_th.max()))
tolerance_rel = 0.1
print("tolerance_rel: " + str(tolerance_rel))
assert np.allclose(E, E_th, atol=tolerance_rel * E_th.max())
check(Ex_array, Ex_th, 'Ex')
check(Ey_array, Ey_th, 'Ey')
if ds.dimensionality == 3:
check(Ez_array, Ez_th, 'Ez')
test_name = filename[:-9] # Could also be os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, filename, do_particles=0)
def do_analysis(single_precision=False):
fn = sys.argv[1]
ds = yt.load(fn)
ad = ds.all_data()
#--------------------------------------------------------------------------------------------------
# Part 1: get results from plotfiles (label '_yt')
#--------------------------------------------------------------------------------------------------
# Quantities computed from plotfiles
values_yt = dict()
# Electrons
px = ad['electrons', 'particle_momentum_x'].to_ndarray()
py = ad['electrons', 'particle_momentum_y'].to_ndarray()
pz = ad['electrons', 'particle_momentum_z'].to_ndarray()
w = ad['electrons', 'particle_weight'].to_ndarray()
p2 = px**2 + py**2 + pz**2
# Accumulate particle energy, store number of particles and sum of weights
e_u2 = p2 / (m_e**2 * c**2)
e_gamma = np.sqrt(1 + e_u2)
e_energy = (m_e * c**2) * np.where(
e_gamma > gamma_relativistic_threshold, e_gamma - 1,
(e_u2) / 2 - (e_u2**2) / 8 + (e_u2**3) / 16 - (e_u2**4) * (5 / 128) +
(e_u2**5) * (7 / 256))
values_yt['electrons: particle energy'] = np.sum(e_energy * w)
values_yt['electrons: particle momentum in x'] = np.sum(px * w)
values_yt['electrons: particle momentum in y'] = np.sum(py * w)
values_yt['electrons: particle momentum in z'] = np.sum(pz * w)
values_yt['electrons: number of particles'] = w.shape[0]
values_yt['electrons: sum of weights'] = np.sum(w)
# Protons
px = ad['protons', 'particle_momentum_x'].to_ndarray()
py = ad['protons', 'particle_momentum_y'].to_ndarray()
pz = ad['protons', 'particle_momentum_z'].to_ndarray()
w = ad['protons', 'particle_weight'].to_ndarray()
p2 = px**2 + py**2 + pz**2
# Accumulate particle energy, store number of particles and sum of weights
p_u2 = p2 / (m_p**2 * c**2)
p_gamma = np.sqrt(1 + p_u2)
p_energy = (m_p * c**2) * np.where(
p_gamma > gamma_relativistic_threshold, p_gamma - 1,
(p_u2) / 2 - (p_u2**2) / 8 + (p_u2**3) / 16 - (p_u2**4) * (5 / 128) +
(p_u2**5) * (7 / 256))
values_yt['protons: particle energy'] = np.sum(p_energy * w)
values_yt['protons: particle momentum in x'] = np.sum(px * w)
values_yt['protons: particle momentum in y'] = np.sum(py * w)
values_yt['protons: particle momentum in z'] = np.sum(pz * w)
values_yt['protons: number of particles'] = w.shape[0]
values_yt['protons: sum of weights'] = np.sum(w)
# Photons
px = ad['photons', 'particle_momentum_x'].to_ndarray()
py = ad['photons', 'particle_momentum_y'].to_ndarray()
pz = ad['photons', 'particle_momentum_z'].to_ndarray()
w = ad['photons', 'particle_weight'].to_ndarray()
p2 = px**2 + py**2 + pz**2
# Accumulate particle energy, store number of particles and sum of weights
values_yt['photons: particle energy'] = np.sum(np.sqrt(p2 * c**2) * w)
values_yt['photons: particle momentum in x'] = np.sum(px * w)
values_yt['photons: particle momentum in y'] = np.sum(py * w)
values_yt['photons: particle momentum in z'] = np.sum(pz * w)
values_yt['photons: number of particles'] = w.shape[0]
values_yt['photons: sum of weights'] = np.sum(w)
# Accumulate total particle diagnostics
values_yt['particle energy'] = values_yt['electrons: particle energy'] \
+ values_yt['protons: particle energy'] \
+ values_yt['photons: particle energy']
values_yt['particle momentum in x'] = values_yt['electrons: particle momentum in x'] \
+ values_yt['protons: particle momentum in x'] \
+ values_yt['photons: particle momentum in x']
values_yt['particle momentum in y'] = values_yt['electrons: particle momentum in y'] \
+ values_yt['protons: particle momentum in y'] \
+ values_yt['photons: particle momentum in y']
values_yt['particle momentum in z'] = values_yt['electrons: particle momentum in z'] \
+ values_yt['protons: particle momentum in z'] \
+ values_yt['photons: particle momentum in z']
values_yt['number of particles'] = values_yt['electrons: number of particles'] \
+ values_yt['protons: number of particles'] \
+ values_yt['photons: number of particles']
values_yt['sum of weights'] = values_yt['electrons: sum of weights'] \
+ values_yt['protons: sum of weights'] \
+ values_yt['photons: sum of weights']
values_yt['mean particle energy'] = values_yt[
'particle energy'] / values_yt['sum of weights']
values_yt['mean particle momentum in x'] = values_yt[
'particle momentum in x'] / values_yt['sum of weights']
values_yt['mean particle momentum in y'] = values_yt[
'particle momentum in y'] / values_yt['sum of weights']
values_yt['mean particle momentum in z'] = values_yt[
'particle momentum in z'] / values_yt['sum of weights']
values_yt['electrons: mean particle energy'] = values_yt['electrons: particle energy'] \
/ values_yt['electrons: sum of weights']
values_yt['electrons: mean particle momentum in x'] = values_yt['electrons: particle momentum in x'] \
/ values_yt['electrons: sum of weights']
values_yt['electrons: mean particle momentum in y'] = values_yt['electrons: particle momentum in y'] \
/ values_yt['electrons: sum of weights']
values_yt['electrons: mean particle momentum in z'] = values_yt['electrons: particle momentum in z'] \
/ values_yt['electrons: sum of weights']
values_yt['protons: mean particle energy'] = values_yt['protons: particle energy'] \
/ values_yt['protons: sum of weights']
values_yt['protons: mean particle momentum in x'] = values_yt['protons: particle momentum in x'] \
/ values_yt['protons: sum of weights']
values_yt['protons: mean particle momentum in y'] = values_yt['protons: particle momentum in y'] \
/ values_yt['protons: sum of weights']
values_yt['protons: mean particle momentum in z'] = values_yt['protons: particle momentum in z'] \
/ values_yt['protons: sum of weights']
values_yt['photons: mean particle energy'] = values_yt['photons: particle energy'] \
/ values_yt['photons: sum of weights']
values_yt['photons: mean particle momentum in x'] = values_yt['photons: particle momentum in x'] \
/ values_yt['photons: sum of weights']
values_yt['photons: mean particle momentum in y'] = values_yt['photons: particle momentum in y'] \
/ values_yt['photons: sum of weights']
values_yt['photons: mean particle momentum in z'] = values_yt['photons: particle momentum in z'] \
/ values_yt['photons: sum of weights']
# Load 3D data from plotfiles
ad = ds.covering_grid(level=0,
left_edge=ds.domain_left_edge,
dims=ds.domain_dimensions)
Ex = ad[('mesh', 'Ex')].to_ndarray()
Ey = ad[('mesh', 'Ey')].to_ndarray()
Ez = ad[('mesh', 'Ez')].to_ndarray()
Bx = ad[('mesh', 'Bx')].to_ndarray()
By = ad[('mesh', 'By')].to_ndarray()
Bz = ad[('mesh', 'Bz')].to_ndarray()
rho = ad[('boxlib', 'rho')].to_ndarray()
rho_electrons = ad[('boxlib', 'rho_electrons')].to_ndarray()
rho_protons = ad[('boxlib', 'rho_protons')].to_ndarray()
x = ad[('boxlib', 'x')].to_ndarray()
y = ad[('boxlib', 'y')].to_ndarray()
z = ad[('boxlib', 'z')].to_ndarray()
# Field energy
E2 = np.sum(Ex**2) + np.sum(Ey**2) + np.sum(Ez**2)
B2 = np.sum(Bx**2) + np.sum(By**2) + np.sum(Bz**2)
N = np.array(ds.domain_width / ds.domain_dimensions)
dV = N[0] * N[1] * N[2]
values_yt['field energy'] = 0.5 * dV * (E2 * eps0 + B2 / mu0)
values_yt['field momentum in x'] = eps0 * np.sum(Ey * Bz - Ez * By) * dV
values_yt['field momentum in y'] = eps0 * np.sum(Ez * Bx - Ex * Bz) * dV
values_yt['field momentum in z'] = eps0 * np.sum(Ex * By - Ey * Bx) * dV
# Field energy in quarter of simulation domain
E2 = np.sum((Ex**2 + Ey**2 + Ez**2) * (y > 0) * (z < 0))
B2 = np.sum((Bx**2 + By**2 + Bz**2) * (y > 0) * (z < 0))
values_yt['field energy in quarter of simulation domain'] = 0.5 * dV * (
E2 * eps0 + B2 / mu0)
# Max/min values of various grid quantities
values_yt['maximum of |Ex|'] = np.amax(np.abs(Ex))
values_yt['maximum of |Ey|'] = np.amax(np.abs(Ey))
values_yt['maximum of |Ez|'] = np.amax(np.abs(Ez))
values_yt['maximum of |Bx|'] = np.amax(np.abs(Bx))
values_yt['maximum of |By|'] = np.amax(np.abs(By))
values_yt['maximum of |Bz|'] = np.amax(np.abs(Bz))
values_yt['maximum of |E|'] = np.amax(np.sqrt(Ex**2 + Ey**2 + Ez**2))
values_yt['maximum of |B|'] = np.amax(np.sqrt(Bx**2 + By**2 + Bz**2))
values_yt['maximum of rho'] = np.amax(rho)
values_yt['minimum of rho'] = np.amin(rho)
values_yt['electrons: maximum of |rho|'] = np.amax(np.abs(rho_electrons))
values_yt['protons: maximum of |rho|'] = np.amax(np.abs(rho_protons))
values_yt['maximum of |B| from generic field reduction'] = np.amax(
np.sqrt(Bx**2 + By**2 + Bz**2))
values_yt['minimum of x*Ey*Bz'] = np.amin(x * Ey * Bz)
#--------------------------------------------------------------------------------------------------
# Part 2: get results from reduced diagnostics (label '_rd')
#--------------------------------------------------------------------------------------------------
# Quantities computed from reduced diagnostics
values_rd = dict()
# Load data from output files
EFdata = np.genfromtxt('./diags/reducedfiles/EF.txt') # Field energy
EPdata = np.genfromtxt('./diags/reducedfiles/EP.txt') # Particle energy
PFdata = np.genfromtxt('./diags/reducedfiles/PF.txt') # Field momentum
PPdata = np.genfromtxt('./diags/reducedfiles/PP.txt') # Particle momentum
MFdata = np.genfromtxt('./diags/reducedfiles/MF.txt') # Field maximum
MRdata = np.genfromtxt('./diags/reducedfiles/MR.txt') # Rho maximum
NPdata = np.genfromtxt('./diags/reducedfiles/NP.txt') # Particle number
FR_Maxdata = np.genfromtxt(
'./diags/reducedfiles/FR_Max.txt') # Field Reduction using maximum
FR_Mindata = np.genfromtxt(
'./diags/reducedfiles/FR_Min.txt') # Field Reduction using minimum
FR_Integraldata = np.genfromtxt('./diags/reducedfiles/FR_Integral.txt'
) # Field Reduction using integral
# First index "1" points to the values written at the last time step
values_rd['field energy'] = EFdata[1][2]
values_rd[
'field energy in quarter of simulation domain'] = FR_Integraldata[1][2]
values_rd['particle energy'] = EPdata[1][2]
values_rd['electrons: particle energy'] = EPdata[1][3]
values_rd['protons: particle energy'] = EPdata[1][4]
values_rd['photons: particle energy'] = EPdata[1][5]
values_rd['mean particle energy'] = EPdata[1][6]
values_rd['electrons: mean particle energy'] = EPdata[1][7]
values_rd['protons: mean particle energy'] = EPdata[1][8]
values_rd['photons: mean particle energy'] = EPdata[1][9]
values_rd['field momentum in x'] = PFdata[1][2]
values_rd['field momentum in y'] = PFdata[1][3]
values_rd['field momentum in z'] = PFdata[1][4]
values_rd['particle momentum in x'] = PPdata[1][2]
values_rd['particle momentum in y'] = PPdata[1][3]
values_rd['particle momentum in z'] = PPdata[1][4]
values_rd['electrons: particle momentum in x'] = PPdata[1][5]
values_rd['electrons: particle momentum in y'] = PPdata[1][6]
values_rd['electrons: particle momentum in z'] = PPdata[1][7]
values_rd['protons: particle momentum in x'] = PPdata[1][8]
values_rd['protons: particle momentum in y'] = PPdata[1][9]
values_rd['protons: particle momentum in z'] = PPdata[1][10]
values_rd['photons: particle momentum in x'] = PPdata[1][11]
values_rd['photons: particle momentum in y'] = PPdata[1][12]
values_rd['photons: particle momentum in z'] = PPdata[1][13]
values_rd['mean particle momentum in x'] = PPdata[1][14]
values_rd['mean particle momentum in y'] = PPdata[1][15]
values_rd['mean particle momentum in z'] = PPdata[1][16]
values_rd['electrons: mean particle momentum in x'] = PPdata[1][17]
values_rd['electrons: mean particle momentum in y'] = PPdata[1][18]
values_rd['electrons: mean particle momentum in z'] = PPdata[1][19]
values_rd['protons: mean particle momentum in x'] = PPdata[1][20]
values_rd['protons: mean particle momentum in y'] = PPdata[1][21]
values_rd['protons: mean particle momentum in z'] = PPdata[1][22]
values_rd['photons: mean particle momentum in x'] = PPdata[1][23]
values_rd['photons: mean particle momentum in y'] = PPdata[1][24]
values_rd['photons: mean particle momentum in z'] = PPdata[1][25]
values_rd['maximum of |Ex|'] = MFdata[1][2]
values_rd['maximum of |Ey|'] = MFdata[1][3]
values_rd['maximum of |Ez|'] = MFdata[1][4]
values_rd['maximum of |E|'] = MFdata[1][5]
values_rd['maximum of |Bx|'] = MFdata[1][6]
values_rd['maximum of |By|'] = MFdata[1][7]
values_rd['maximum of |Bz|'] = MFdata[1][8]
values_rd['maximum of |B|'] = MFdata[1][9]
values_rd['maximum of rho'] = MRdata[1][2]
values_rd['minimum of rho'] = MRdata[1][3]
values_rd['electrons: maximum of |rho|'] = MRdata[1][4]
values_rd['protons: maximum of |rho|'] = MRdata[1][5]
values_rd['number of particles'] = NPdata[1][2]
values_rd['electrons: number of particles'] = NPdata[1][3]
values_rd['protons: number of particles'] = NPdata[1][4]
values_rd['photons: number of particles'] = NPdata[1][5]
values_rd['sum of weights'] = NPdata[1][6]
values_rd['electrons: sum of weights'] = NPdata[1][7]
values_rd['protons: sum of weights'] = NPdata[1][8]
values_rd['photons: sum of weights'] = NPdata[1][9]
values_rd['maximum of |B| from generic field reduction'] = FR_Maxdata[1][2]
values_rd['minimum of x*Ey*Bz'] = FR_Mindata[1][2]
#--------------------------------------------------------------------------------------------------
# Part 3: compare values from plotfiles and reduced diagnostics and print output
#--------------------------------------------------------------------------------------------------
error = dict()
tolerance = 5e-3 if single_precision else 1e-12
field_energy_tolerance = 0.3
# The comparison of field energies requires a large tolerance,
# because the field energy from the plotfiles is computed from cell-centered data,
# while the field energy from the reduced diagnostics is computed from (Yee) staggered data.
for k in values_yt.keys():
print()
print('values_yt[' + k + '] = ', values_yt[k])
print('values_rd[' + k + '] = ', values_rd[k])
error[k] = abs(values_yt[k] - values_rd[k]) / abs(values_yt[k])
print('relative error = ', error[k])
tol = field_energy_tolerance if (k == 'field energy') else tolerance
assert (error[k] < tol)
print()
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, fn)
# Check that the number of particles at the level weight is the same as predicted from analytic
# calculations
numparts_leveled = np.argmax(
w > level_weight) # This returns the first index for which
# w > level_weight, which thus corresponds to the number of particles at the level weight
expected_numparts_leveled = numparts_init/(2.*t_r)*(1+erf(expected_mean_initial_weight*(t_r-1.)) \
-1./(np.sqrt(np.pi)*expected_mean_initial_weight)* \
np.exp(-(expected_mean_initial_weight*(t_r-1.))**2))
error = np.abs(numparts_leveled - expected_numparts_leveled)
std_numparts_leveled = np.sqrt(expected_numparts_leveled - numparts_init/np.sqrt(np.pi)/(t_r* \
expected_mean_initial_weight)**2*(np.sqrt(np.pi)/4.* \
(2.*expected_mean_initial_weight**2+1.)*(1.-erf(expected_mean_initial_weight* \
(t_r-1.)))-0.5*np.exp(-(expected_mean_initial_weight*(t_r-1.))**2* \
(expected_mean_initial_weight*(t_r+1.)))))
# 5 sigma test that has an intrinsic probability to fail of 1 over ~2 millions
print(
"difference between expected and actual number of leveled particles (2nd species): "
+ str(error))
print("tolerance: " + str(5 * std_numparts_leveled))
numparts_unaffected = w.shape[0] - numparts_leveled
numparts_unaffected_anticipated = w0.shape[0] - np.argmax(w0 > level_weight)
# Check that number of particles with weight higher than level weight is the same before and after
# resampling
assert (numparts_unaffected == numparts_unaffected_anticipated)
# Check that particles with weight higher than level weight are unaffected by resampling.
assert (np.all(w[-numparts_unaffected:] == w0[-numparts_unaffected:]))
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, fn_final)
Ey = ad['Ey'].to_ndarray()
Ez = ad['Ez'].to_ndarray()
Bx = ad['Bx'].to_ndarray()
By = ad['By'].to_ndarray()
Bz = ad['Bz'].to_ndarray()
Es = np.sum(Ex**2)+np.sum(Ey**2)+np.sum(Ez**2)
Bs = np.sum(Bx**2)+np.sum(By**2)+np.sum(Bz**2)
N = np.array( ds.domain_width / ds.domain_dimensions )
dV = N[0]*N[1]*N[2]
EFyt = 0.5*Es*scc.epsilon_0*dV + 0.5*Bs/scc.mu_0*dV
# PART2: get results from reduced diagnostics
EFdata = np.genfromtxt("./diags/reducedfiles/EF.txt")
EPdata = np.genfromtxt("./diags/reducedfiles/EP.txt")
EF = EFdata[1][2]
EP = EPdata[1][2]
# PART3: print and assert
print('difference of field energy:', abs(EFyt-EF))
print('tolerance of field energy:', 1.0e-3)
print('difference of particle energy:', abs(EPyt-EP))
print('tolerance of particle energy:', 1.0e-8)
assert(abs(EFyt-EF) < 1.0e-3)
assert(abs(EPyt-EP) < 1.0e-8)
test_name = fn[:-9] # Could also be os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, fn)
plt.tight_layout()
plt.savefig('langmuir_multi_analysis.png')
tolerance_rel = 0.15
print("error_rel : " + str(error_rel))
print("tolerance_rel: " + str(tolerance_rel))
assert (error_rel < tolerance_rel)
# Check relative L-infinity spatial norm of rho/epsilon_0 - div(E) when
# current correction (psatd.do_current_correction=1) is applied or when
# Vay current deposition (algo.current_deposition=vay) is used
if current_correction or vay_deposition:
rho = data['rho'].to_ndarray()
divE = data['divE'].to_ndarray()
error_rel = np.amax(np.abs(divE - rho / epsilon_0)) / np.amax(
np.abs(rho / epsilon_0))
tolerance = 1.e-9
print("Check charge conservation:")
print("error_rel = {}".format(error_rel))
print("tolerance = {}".format(tolerance))
assert (error_rel < tolerance)
test_name = fn[:-9] # Could also be os.path.split(os.getcwd())[1]
if re.search('single_precision', fn):
checksumAPI.evaluate_checksum(test_name, fn, rtol=1.e-3)
else:
checksumAPI.evaluate_checksum(test_name, fn)
def do_analysis(single_precision=False):
fn = sys.argv[1]
ds = yt.load(fn)
ad = ds.all_data()
ad0 = ds.covering_grid(level=0,
left_edge=ds.domain_left_edge,
dims=ds.domain_dimensions)
opmd = io.Series('diags/openpmd/openpmd_%T.h5', io.Access.read_only)
opmd_i = opmd.iterations[200]
#--------------------------------------------------------------------------------------------------
# Part 1: get results from plotfiles (label '_yt')
#--------------------------------------------------------------------------------------------------
# Quantities computed from plotfiles
values_yt = dict()
domain_size = ds.domain_right_edge.value - ds.domain_left_edge.value
dx = domain_size / ds.domain_dimensions
# Electrons
x = ad['electrons', 'particle_position_x'].to_ndarray()
y = ad['electrons', 'particle_position_y'].to_ndarray()
z = ad['electrons', 'particle_position_z'].to_ndarray()
uz = ad['electrons', 'particle_momentum_z'].to_ndarray() / m_e / c
w = ad['electrons', 'particle_weight'].to_ndarray()
filt = uz < 0
x_ind = ((x - ds.domain_left_edge[0].value) / dx[0]).astype(int)
y_ind = ((y - ds.domain_left_edge[1].value) / dx[1]).astype(int)
z_ind = ((z - ds.domain_left_edge[2].value) / dx[2]).astype(int)
zavg = np.zeros(ds.domain_dimensions)
uzavg = np.zeros(ds.domain_dimensions)
zuzavg = np.zeros(ds.domain_dimensions)
wavg = np.zeros(ds.domain_dimensions)
uzavg_filt = np.zeros(ds.domain_dimensions)
wavg_filt = np.zeros(ds.domain_dimensions)
for i_p in range(len(x)):
zavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * w[i_p]
uzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += uz[i_p] * w[i_p]
zuzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * uz[i_p] * w[i_p]
wavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += w[i_p]
uzavg_filt[x_ind[i_p], y_ind[i_p],
z_ind[i_p]] += uz[i_p] * w[i_p] * filt[i_p]
wavg_filt[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += w[i_p] * filt[i_p]
wavg_adj = np.where(wavg == 0, 1, wavg)
wavg_filt_adj = np.where(wavg_filt == 0, 1, wavg_filt)
values_yt['electrons: zavg'] = zavg / wavg_adj
values_yt['electrons: uzavg'] = uzavg / wavg_adj
values_yt['electrons: zuzavg'] = zuzavg / wavg_adj
values_yt['electrons: uzavg_filt'] = uzavg_filt / wavg_filt_adj
# protons
x = ad['protons', 'particle_position_x'].to_ndarray()
y = ad['protons', 'particle_position_y'].to_ndarray()
z = ad['protons', 'particle_position_z'].to_ndarray()
uz = ad['protons', 'particle_momentum_z'].to_ndarray() / m_p / c
w = ad['protons', 'particle_weight'].to_ndarray()
filt = uz < 0
x_ind = ((x - ds.domain_left_edge[0].value) / dx[0]).astype(int)
y_ind = ((y - ds.domain_left_edge[1].value) / dx[1]).astype(int)
z_ind = ((z - ds.domain_left_edge[2].value) / dx[2]).astype(int)
zavg = np.zeros(ds.domain_dimensions)
uzavg = np.zeros(ds.domain_dimensions)
zuzavg = np.zeros(ds.domain_dimensions)
wavg = np.zeros(ds.domain_dimensions)
uzavg_filt = np.zeros(ds.domain_dimensions)
wavg_filt = np.zeros(ds.domain_dimensions)
for i_p in range(len(x)):
zavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * w[i_p]
uzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += uz[i_p] * w[i_p]
zuzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * uz[i_p] * w[i_p]
wavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += w[i_p]
uzavg_filt[x_ind[i_p], y_ind[i_p],
z_ind[i_p]] += uz[i_p] * w[i_p] * filt[i_p]
wavg_filt[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += w[i_p] * filt[i_p]
wavg_adj = np.where(wavg == 0, 1, wavg)
wavg_filt_adj = np.where(wavg_filt == 0, 1, wavg_filt)
values_yt['protons: zavg'] = zavg / wavg_adj
values_yt['protons: uzavg'] = uzavg / wavg_adj
values_yt['protons: zuzavg'] = zuzavg / wavg_adj
values_yt['protons: uzavg_filt'] = uzavg_filt / wavg_filt_adj
# Photons (momentum in units of m_e c)
x = ad['photons', 'particle_position_x'].to_ndarray()
y = ad['photons', 'particle_position_y'].to_ndarray()
z = ad['photons', 'particle_position_z'].to_ndarray()
uz = ad['photons', 'particle_momentum_z'].to_ndarray() / m_e / c
w = ad['photons', 'particle_weight'].to_ndarray()
filt = uz < 0
x_ind = ((x - ds.domain_left_edge[0].value) / dx[0]).astype(int)
y_ind = ((y - ds.domain_left_edge[1].value) / dx[1]).astype(int)
z_ind = ((z - ds.domain_left_edge[2].value) / dx[2]).astype(int)
zavg = np.zeros(ds.domain_dimensions)
uzavg = np.zeros(ds.domain_dimensions)
zuzavg = np.zeros(ds.domain_dimensions)
wavg = np.zeros(ds.domain_dimensions)
uzavg_filt = np.zeros(ds.domain_dimensions)
wavg_filt = np.zeros(ds.domain_dimensions)
for i_p in range(len(x)):
zavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * w[i_p]
uzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += uz[i_p] * w[i_p]
zuzavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += z[i_p] * uz[i_p] * w[i_p]
wavg[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += w[i_p]
uzavg_filt[x_ind[i_p], y_ind[i_p],
z_ind[i_p]] += uz[i_p] * w[i_p] * filt[i_p]
wavg_filt[x_ind[i_p], y_ind[i_p], z_ind[i_p]] += w[i_p] * filt[i_p]
wavg_adj = np.where(wavg == 0, 1, wavg)
wavg_filt_adj = np.where(wavg_filt == 0, 1, wavg_filt)
values_yt['photons: zavg'] = zavg / wavg_adj
values_yt['photons: uzavg'] = uzavg / wavg_adj
values_yt['photons: zuzavg'] = zuzavg / wavg_adj
values_yt['photons: uzavg_filt'] = uzavg_filt / wavg_filt_adj
values_rd = dict()
# Load reduced particle diagnostic data from plotfiles
values_rd['electrons: zavg'] = ad0[('boxlib', 'z_electrons')]
values_rd['protons: zavg'] = ad0[('boxlib', 'z_protons')]
values_rd['photons: zavg'] = ad0[('boxlib', 'z_photons')]
values_rd['electrons: uzavg'] = ad0[('boxlib', 'uz_electrons')]
values_rd['protons: uzavg'] = ad0[('boxlib', 'uz_protons')]
values_rd['photons: uzavg'] = ad0[('boxlib', 'uz_photons')]
values_rd['electrons: zuzavg'] = ad0[('boxlib', 'zuz_electrons')]
values_rd['protons: zuzavg'] = ad0[('boxlib', 'zuz_protons')]
values_rd['photons: zuzavg'] = ad0[('boxlib', 'zuz_photons')]
values_rd['electrons: uzavg_filt'] = ad0[('boxlib', 'uz_filt_electrons')]
values_rd['protons: uzavg_filt'] = ad0[('boxlib', 'uz_filt_protons')]
values_rd['photons: uzavg_filt'] = ad0[('boxlib', 'uz_filt_photons')]
values_opmd = dict()
# Load reduced particle diagnostic data from OPMD output
values_opmd['electrons: zavg'] = opmd_i.meshes['z_electrons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['protons: zavg'] = opmd_i.meshes['z_protons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['photons: zavg'] = opmd_i.meshes['z_photons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['electrons: uzavg'] = opmd_i.meshes['uz_electrons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['protons: uzavg'] = opmd_i.meshes['uz_protons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['photons: uzavg'] = opmd_i.meshes['uz_photons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['electrons: zuzavg'] = opmd_i.meshes['zuz_electrons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['protons: zuzavg'] = opmd_i.meshes['zuz_protons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['photons: zuzavg'] = opmd_i.meshes['zuz_photons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['electrons: uzavg_filt'] = opmd_i.meshes['uz_filt_electrons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['protons: uzavg_filt'] = opmd_i.meshes['uz_filt_protons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
values_opmd['photons: uzavg_filt'] = opmd_i.meshes['uz_filt_photons'][
io.Mesh_Record_Component.SCALAR].load_chunk()
opmd.flush()
del opmd
#--------------------------------------------------------------------------------------------------
# Part 3: compare values from plotfiles and diagnostics and print output
#--------------------------------------------------------------------------------------------------
error_plt = dict()
error_opmd = dict()
tolerance = 5e-3 if single_precision else 1e-12
# if single precision, increase tolerance from default value
check_tolerance = 5e-3 if single_precision else 1e-9
for k in values_yt.keys():
# check that the zeros line up, since we'll be ignoring them in the error calculation
assert (np.all((values_yt[k] == 0) == (values_rd[k] == 0)))
error_plt[k] = np.max(
abs(values_yt[k] - values_rd[k])[values_yt[k] != 0] /
abs(values_yt[k])[values_yt[k] != 0])
print(k, 'relative error plotfile = ', error_plt[k])
assert (error_plt[k] < tolerance)
assert (np.all((values_yt[k] == 0) == (values_opmd[k].T == 0)))
error_opmd[k] = np.max(
abs(values_yt[k] - values_opmd[k].T)[values_yt[k] != 0] /
abs(values_yt[k])[values_yt[k] != 0])
assert (error_opmd[k] < tolerance)
print(k, 'relative error openPMD = ', error_opmd[k])
test_name = os.path.split(os.getcwd())[1]
checksumAPI.evaluate_checksum(test_name, fn, rtol=check_tolerance)
