def check_identical_fields( folder1, folder2 ):
ts1 = OpenPMDTimeSeries( folder1 )
ts2 = OpenPMDTimeSeries( folder2 )
# Check the vector fields
for field, coord in [("J", "z"), ("E","r"), ("E","z"), ("B","t")]:
print("Checking %s%s" %(field, coord))
field1, info = ts1.get_field(field, coord, iteration=0)
field2, info = ts2.get_field(field, coord, iteration=0)
# For 0 fields, do not use allclose
if abs(field1).max() == 0:
assert abs(field2).max() == 0
else:
assert np.allclose(
field1/abs(field1).max(), field2/abs(field2).max() )
# Check the rho field
print("Checking rho")
field1, info = ts1.get_field("rho", iteration=0)
field2, info = ts2.get_field("rho", iteration=0)
assert np.allclose( field1/abs(field1).max(), field2/abs(field2).max() )
def check_theory_gaussian():
"""
Check that the transverse E and B field are close to the high-gamma
theory for a gaussian bunch
"""
ts = OpenPMDTimeSeries( os.path.join(temporary_dir, 'diags_serial/hdf5/') )
Ex, info = ts.get_field( 'E', 'x', iteration=0 )
By, info = ts.get_field( 'B', 'y', iteration=0 )
r, z = np.meshgrid( info.r, info.z, indexing='ij' )
# High-gamma theory for Gaussian bunch
Eth = -Q/(2*np.pi)**1.5/sig_z/epsilon_0/r * \
(1 - np.exp(-0.5*r**2/sig_r**2)) * \
np.exp( -0.5*(z-zf)**2/sig_z**2)
Bth = Eth/c
# Check that the fields agree
assert np.allclose( Ex, Eth, atol=0.1*Eth.max() )
assert np.allclose( By, Bth, atol=0.1*Bth.max() )
# read in the longitdunal electric field component
path_to_data = '../../rsfbpic/package_data'
field_name = 'E'
coord = 'z'
iteration = 280
mode = 0
theta = 0.
plot = False
# open the file; instantiate "time series" object
time_series = OpenPMDTimeSeries(path_to_data)
# read the specified field
ez, info_ez = time_series.get_field(iteration=iteration, \
field=field_name, \
coord=coord, \
m=mode, \
theta=theta, \
plot=plot)
print()
print("axes = ", info_ez.axes)
print()
print("rmin, rmax = ", info_ez.rmin, "; ", info_ez.rmax)
print("zmin, zmax = ", info_ez.zmin, "; ", info_ez.zmax)
print()
print("dz = ", info_ez.dz)
print("dr = ", info_ez.dr)
print()
# print("r = ", info_ez.r)
# print("z = ", info_ez.z)
print("N_cells_r = ", len(info_ez.r))
class OpenPMDFieldReader(FieldReaderBase):
def __init__(self, location, speciesName, dataName, firstTimeStep):
# First check whether openPMD is installed
if not openpmd_installed:
raise RunTimeError(
"You need to install openPMD-viewer, e.g. with:\n"
"pip install openPMD-viewer")
# Store an openPMD timeseries object
# (Its API is used in order to conveniently extract data from the file)
self.openpmd_ts = OpenPMDTimeSeries(location, check_all_files=False)
self.openpmd_dataName = dataName
# Initialize the instance
FieldReaderBase.__init__(self, location, speciesName, dataName,
firstTimeStep)
def _ReadBasicData(self):
file_content = self._OpenFile(self.firstTimeStep)
self._ReadInternalName(file_content)
self._DetermineFieldDimension(file_content)
self._GetMatrixShape(file_content)
self._ReadSimulationProperties(file_content)
file_content.close()
def _GetMatrixShape(self, file_content):
_, dataset = openpmd_find_dataset(file_content, self.internalName)
self.matrixShape = openpmd_get_shape(dataset)
def _ReadInternalName(self, file_content):
self.internalName = self.openpmd_dataName
def _DetermineFieldDimension(self, file_content):
# Find the name of the field ; vector fields like E are encoded as "E/x"
fieldname = self.internalName.split("/")[0]
geometry = self.openpmd_ts.fields_metadata[fieldname]['geometry']
if geometry == '3dcartesian':
self.fieldDimension = "3D"
elif geometry == '2dcartesian':
self.fieldDimension = "2D"
else:
raise ValueError("Unsupported geometry: %s" % geometry)
def _Read1DSlice(self, timeStep, slicePositionX, slicePositionY=None):
# Find the name of the field ; vector fields like E are encoded as "E/x"
field_and_coord = self.internalName.split("/")
if self.fieldDimension == '2D':
fieldData, _ = self.openpmd_ts.get_field(*field_and_coord,
iteration=timeStep)
elementsX = self.matrixShape[-2]
selectedRow = round(elementsX * (float(slicePositionX) / 100))
sliceData = np.array(fieldData[selectedRow])
elif self.fieldDimension == '3D':
# Slice first along X
fieldData = self._Read2DSlice(None, slicePositionX, timeStep)
# Then slice along Y
elementsY = self.matrixShape[-2]
selectedY = round(elementsY * (float(slicePositionY) / 100))
sliceData = np.array(fieldData[selectedY])
return sliceData
def _Read2DSlice(self, sliceAxis, slicePosition, timeStep):
# Find the name of the field ; vector fields like E are encoded as "E/x"
field_and_coord = self.internalName.split("/")
# Convert the `slicePosition` from a 0-to-100 number to -1 to 1
slicing = -1. + 2 * slicePosition / 100.
# Extract the slice
sliceData, _ = self.openpmd_ts.get_field(*field_and_coord,
iteration=timeStep,
slicing_dir="x",
slicing=slicing)
return sliceData
def _ReadAllFieldData(self, timeStep):
# Find the name of the field ; vector fields like E are encoded as "E/x"
field_and_coord = self.internalName.split("/")
fieldData, _ = self.openpmd_ts.get_field(*field_and_coord,
iteration=timeStep,
slicing=None)
return fieldData
def _ReadAxisData(self, timeStep):
# Find the name of the field ; vector fields like E are encoded as "E/x"
field_and_coord = self.internalName.split("/")
# Note: the code below has very bad performance because
# it automatically reads the field data, just to extract the metadata
# TODO: improve in the future
_, field_meta_data = self.openpmd_ts.get_field(*field_and_coord,
iteration=timeStep,
slicing=None)
# Construct the `axisData` from the object `field_meta_data`
axisData = {}
axisData["x"] = getattr(field_meta_data, "z")
axisData["y"] = getattr(field_meta_data, "x")
if self.fieldDimension == "3D":
axisData["z"] = getattr(field_meta_data, "y")
return axisData
def _ReadTime(self, timeStep):
# The line below sets the attribute `_current_i` of openpmd_ts
self.openpmd_ts._find_output(None, timeStep)
# This sets the corresponding time
self.currentTime = self.openpmd_ts.t[self.openpmd_ts._current_i]
def _ReadUnits(self):
file_content = self._OpenFile(self.firstTimeStep)
# OpenPMD data always provide conversion to SI units
self.axisUnits["x"] = "m"
self.axisUnits["y"] = "m"
self.axisUnits["z"] = "m"
self.timeUnits = "t"
self.dataUnits = "arb.u." # TODO find the exact unit; needs navigation in file
file_content.close()
def _ReadSimulationProperties(self, file_content):
# TODO: add the proper resolution
self.grid_resolution = None
self.grid_size = None
self.grid_units = "m"
def _OpenFile(self, timeStep):
# The line below sets the attribute `_current_i` of openpmd_ts
self.openpmd_ts._find_output(None, timeStep)
# This finds the full path to the corresponding file
fileName = self.openpmd_ts.h5_files[self.openpmd_ts._current_i]
file_content = H5File(fileName, 'r')
return file_content
factor = 1
a0PerSnapshot = []
PulsewaistPerSnapshot = []
PulselengthPerSnapshot = []
EzMinPerSnapshot = []
MaxFrequencyTrailingPulse = []
#for i in range(0,int(ts_laser.iterations.size/factor)):
for i in range(10800, 10801):
iter = 10800
#iter = ts_laser.iterations[factor*i]
print('Iteration:%d' % iter)
Ez, info_Ez = ts_particles.get_field(iteration=iter,
field='E',
coord='z',
plot=True,
**particles)
#plt.clim(-5e8,5e8)
plt.savefig('%s/Ez_Iteration%09i.png' % (Path + '/Ez', iter),
bbox_inches='tight')
plt.close()
fig2, axis2 = plt.subplots()
plt.locator_params(nbins=20, axis='y')
plt.locator_params(nbins=20, axis='x')
plt.plot(Ez[600])
#axis2.xaxis.grid(linestyle='solid',color='gray',linewidth=0.1)
#axis2.yaxis.grid(linestyle='solid',color='gray',linewidth=0.1)
plt.savefig('EzLineout_%09i.png' % (iter), bbox_inches='tight')
def test_cpu_gpu_deposition(show=False):
"Function that is run by py.test, when doing `python setup.py test`"
# Skip this test if cuda is not installed
if not cuda_installed:
return
# Perform deposition for a few timesteps, with both the CPU and GPU
for hardware in ['cpu', 'gpu']:
if hardware == 'cpu':
use_cuda = False
elif hardware == 'gpu':
use_cuda = True
# Initialize the simulation object
sim = Simulation(Nz,
zmax,
Nr,
rmax,
Nm,
dt,
p_zmin,
p_zmax,
p_rmin,
p_rmax,
p_nz,
p_nr,
p_nt,
n_e,
zmin=zmin,
use_cuda=use_cuda)
# Tweak the velocity of the electron bunch
gamma0 = 10.
sim.ptcl[0].ux = sim.ptcl[0].x
sim.ptcl[0].uy = sim.ptcl[0].y
sim.ptcl[0].uz = np.sqrt(gamma0**2 - sim.ptcl[0].ux**2 -
sim.ptcl[0].uy**2 - 1)
sim.ptcl[0].inv_gamma = 1. / gamma0 * np.ones_like(sim.ptcl[0].x)
sim.ptcl[0].m = 1e10
# Add a field diagnostic
sim.diags = [
FieldDiagnostic(diag_period,
sim.fld,
fieldtypes=['rho', 'J'],
comm=sim.comm,
write_dir=os.path.join('tests', hardware))
]
### Run the simulation
sim.step(N_step)
# Check that the results are identical
ts_cpu = OpenPMDTimeSeries('tests/cpu/hdf5')
ts_gpu = OpenPMDTimeSeries('tests/gpu/hdf5')
for iteration in ts_cpu.iterations:
for field, coord in [('rho', ''), ('J', 'x'), ('J', 'z')]:
# Jy is not tested because it is zero
print('Testing %s at iteration %d' % (field + coord, iteration))
F_cpu, info = ts_cpu.get_field(field, coord, iteration=iteration)
F_gpu, info = ts_gpu.get_field(field, coord, iteration=iteration)
tolerance = 1.e-13 * (abs(F_cpu).max() + abs(F_gpu).max())
if not show:
assert np.allclose(F_cpu, F_gpu, atol=tolerance)
else:
if not np.allclose(F_cpu, F_gpu, atol=tolerance):
plot_difference(field, coord, iteration, F_cpu, F_gpu,
info)
# Remove the files used
shutil.rmtree('tests/cpu')
shutil.rmtree('tests/gpu')
def run_cpu_gpu_deposition(show=False, particle_shape='cubic'):
# Skip this test if cuda is not installed
if not cuda_installed:
return
# Perform deposition for a few timesteps, with both the CPU and GPU
for hardware in ['cpu', 'gpu']:
if hardware == 'cpu':
use_cuda = False
elif hardware == 'gpu':
use_cuda = True
# Initialize the simulation object
sim = Simulation(Nz,
zmax,
Nr,
rmax,
Nm,
dt,
zmin=zmin,
use_cuda=use_cuda,
particle_shape=particle_shape)
sim.ptcl = []
# Add an electron bunch (set the random seed first)
np.random.seed(0)
add_elec_bunch_gaussian(sim, sig_r, sig_z, n_emit, gamma0, sig_gamma,
Q, N)
# Add a field diagnostic
sim.diags = [
FieldDiagnostic(diag_period,
sim.fld,
fieldtypes=['rho', 'J'],
comm=sim.comm,
write_dir=os.path.join('tests', hardware))
]
### Run the simulation
sim.step(N_step)
# Check that the results are identical
ts_cpu = OpenPMDTimeSeries('tests/cpu/hdf5')
ts_gpu = OpenPMDTimeSeries('tests/gpu/hdf5')
for iteration in ts_cpu.iterations:
for field, coord in [('rho', ''), ('J', 'x'), ('J', 'z')]:
# Jy is not tested because it is zero
print('Testing %s at iteration %d' % (field + coord, iteration))
F_cpu, info = ts_cpu.get_field(field, coord, iteration=iteration)
F_gpu, info = ts_gpu.get_field(field, coord, iteration=iteration)
tolerance = 1.e-13 * (abs(F_cpu).max() + abs(F_gpu).max())
if not show:
assert np.allclose(F_cpu, F_gpu, atol=tolerance)
else:
if not np.allclose(F_cpu, F_gpu, atol=tolerance):
plot_difference(field, coord, iteration, F_cpu, F_gpu,
info)
# Remove the files used
shutil.rmtree('tests/cpu')
shutil.rmtree('tests/gpu')