def runTest(self):
nx, ny, nz, str_f, pt0, pt1 = self.args
slidx = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '')
getf = GetFields(fields, str_f, pt0, pt1)
# host allocations
eh_dict = {}
for sf in str_fs:
eh_dict[sf] = np.random.rand(*fields.ns).astype(fields.dtype)
cl.enqueue_copy(fields.queue, fields.get_buf(sf), eh_dict[sf])
# verify
getf.get_event().wait()
for str_f in str_fs:
original = eh_dict[str_f][slidx]
copy = getf.get_fields(str_f)
self.assertEqual(
np.abs(eh_dict[str_f][slidx] - getf.get_fields(str_f)).max(),
0, self.args)
def runTest(self):
nx, ny, nz, str_f, pt0, pt1 = self.args
slidx = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '')
getf = GetFields(fields, str_f, pt0, pt1)
# host allocations
eh_dict = {}
for sf in str_fs:
eh_dict[sf] = np.random.rand(*fields.ns).astype(fields.dtype)
cl.enqueue_copy(fields.queue, fields.get_buf(sf), eh_dict[sf])
# verify
getf.get_event().wait()
for str_f in str_fs:
original = eh_dict[str_f][slidx]
copy = getf.get_fields(str_f)
self.assertEqual(np.abs(eh_dict[str_f][slidx] - getf.get_fields(str_f)).max(), 0, self.args)
def __init__(self, fields, str_f, pt0, pt1):
"""
"""
common.check_type('fields', fields, Fields)
common.check_type('str_f', str_f, (str, list, tuple), str)
common.check_type('pt0', pt0, (list, tuple), int)
common.check_type('pt1', pt1, (list, tuple), int)
# local variables
str_fs = common.convert_to_tuple(str_f)
for strf in str_fs:
strf_list = ['ex', 'ey', 'ez', 'hx', 'hy', 'hz']
common.check_value('str_f', strf, strf_list)
for axis, n, p0, p1 in zip(['x', 'y', 'z'], fields.ns, pt0, pt1):
common.check_value('pt0 %s' % axis, p0, range(n))
common.check_value('pt1 %s' % axis, p1, range(n))
# allocation
shape = common.shape_two_points(pt0, pt1, len(str_fs))
host_array = np.zeros(shape, dtype=fields.dtype)
split_host_array = np.split(host_array, len(str_fs))
split_host_array_dict = dict(zip(str_fs, split_host_array))
# global variables
self.mainf = fields
self.str_fs = str_fs
self.slice_xyz = common.slice_index_two_points(pt0, pt1)
self.host_array = host_array
self.split_host_array_dict = split_host_array_dict
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array, mpi_type = self.args
slices = common.slice_index_two_points(pt0, pt1)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1)
value = np.random.rand(*shape).astype(np.float32)
else:
value = np.random.ranf()
# instance
fields = Fields(nx, ny, nz, '', 'single', 0, mpi_type=mpi_type)
tfunc = lambda tstep: np.sin(0.03 * tstep)
incident = DirectIncident(fields, str_f, pt0, pt1, tfunc, value)
# host allocations
eh = np.zeros(fields.ns_pitch, dtype=fields.dtype)
getf = GetFields(fields, str_f, pt0, pt1)
# verify
eh[slices] = fields.dtype(value) * fields.dtype(tfunc(1))
fields.update_e()
fields.update_h()
fields.enqueue_barrier()
original = eh[slices]
getf.get_event().wait()
copy = getf.get_fields()
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array, mpi_type = self.args
slices = common.slice_index_two_points(pt0, pt1)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1)
value = np.random.rand(*shape).astype(np.float32)
else:
value = np.random.ranf()
# instance
fields = Fields(nx, ny, nz, '', 'single', 0, mpi_type=mpi_type)
tfunc = lambda tstep: np.sin(0.03*tstep)
incident = DirectIncident(fields, str_f, pt0, pt1, tfunc, value)
# host allocations
eh = np.zeros(fields.ns_pitch, dtype=fields.dtype)
getf = GetFields(fields, str_f, pt0, pt1)
# verify
eh[slices] = fields.dtype(value) * fields.dtype(tfunc(1))
fields.update_e()
fields.update_h()
fields.enqueue_barrier()
original = eh[slices]
getf.get_event().wait()
copy = getf.get_fields()
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1 = self.args
slidx = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '', 'single')
getf = GetFields(fields, str_f, pt0, pt1)
# host allocations
ehs = common_update.generate_random_ehs(nx, ny, nz, fields.dtype)
eh_dict = dict( zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], ehs) )
fields.set_eh_bufs(*ehs)
# verify
getf.get_event().wait()
for str_f in str_fs:
original = eh_dict[str_f][slidx]
copy = getf.get_fields(str_f)
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def __init__(self, fields, str_f, pt0, pt1, is_array=False, is_overwrite=True):
"""
"""
common.check_type("fields", fields, Fields)
common.check_type("str_f", str_f, (str, list, tuple), str)
common.check_type("pt0", pt0, (list, tuple), int)
common.check_type("pt1", pt1, (list, tuple), int)
common.check_type("is_array", is_array, bool)
common.check_type("is_overwrite", is_overwrite, bool)
# local variables
str_fs = common.convert_to_tuple(str_f)
for strf in str_fs:
strf_list = ["ex", "ey", "ez", "hx", "hy", "hz"]
common.check_value("str_f", strf, strf_list)
for axis, n, p0, p1 in zip(["x", "y", "z"], fields.ns, pt0, pt1):
common.check_value("pt0 %s" % axis, p0, range(n))
common.check_value("pt1 %s" % axis, p1, range(n))
# global variables and functions
self.mainf = fields
self.str_fs = str_fs
self.slice_xyz = common.slice_index_two_points(pt0, pt1)
self.shape = common.shape_two_points(pt0, pt1, len(str_fs))
self.is_overwrite = is_overwrite
if is_array:
self.func = self.set_fields_spatial_value
else:
self.func = self.set_fields_single_value
def __init__(self, fields, str_f, pt0, pt1):
"""
"""
common.check_type("fields", fields, Fields)
common.check_type("str_f", str_f, (str, list, tuple), str)
common.check_type("pt0", pt0, (list, tuple), int)
common.check_type("pt1", pt1, (list, tuple), int)
# local variables
str_fs = common.convert_to_tuple(str_f)
for strf in str_fs:
strf_list = ["ex", "ey", "ez", "hx", "hy", "hz"]
common.check_value("str_f", strf, strf_list)
for axis, n, p0, p1 in zip(["x", "y", "z"], fields.ns, pt0, pt1):
common.check_value("pt0 %s" % axis, p0, range(n))
common.check_value("pt1 %s" % axis, p1, range(n))
# allocation
shape = common.shape_two_points(pt0, pt1, len(str_fs))
host_array = np.zeros(shape, dtype=fields.dtype)
split_host_array = np.split(host_array, len(str_fs))
split_host_array_dict = dict(zip(str_fs, split_host_array))
# global variables
self.mainf = fields
self.str_fs = str_fs
self.slice_xyz = common.slice_index_two_points(pt0, pt1)
self.host_array = host_array
self.split_host_array_dict = split_host_array_dict
def runTest(self):
nx, ny, nz, str_f, pt0, pt1 = self.args
slidx = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '', 'single')
getf = GetFields(fields, str_f, pt0, pt1)
# host allocations
ehs = common_update.generate_random_ehs(nx, ny, nz, fields.dtype)
eh_dict = dict(zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], ehs))
fields.set_eh_bufs(*ehs)
# verify
getf.get_event().wait()
for str_f in str_fs:
original = eh_dict[str_f][slidx]
copy = getf.get_fields(str_f)
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
if len(self.args) == 6:
nx, ny, nz, str_f, pt0, pt1 = self.args
src_is_array = False
elif len(self.args) == 7:
nx, ny, nz, str_f, pt0, pt1, src_is_array = self.args
slidx = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '')
setf = SetFields(fields, str_f, pt0, pt1, src_is_array)
# generate random source
if src_is_array:
shape = list(common.shape_two_points(pt0, pt1))
shape[0] *= len(str_fs)
value = np.random.rand(*shape).astype(fields.dtype)
split_value = np.split(value, len(str_fs))
split_value_dict = dict(zip(str_fs, split_value))
else:
value = np.random.ranf()
# host allocations
eh_dict = {}
for sf in str_fs:
eh_dict[sf] = np.zeros(fields.ns, dtype=fields.dtype)
gpu_eh = np.zeros(fields.ns, dtype=fields.dtype)
# verify
for str_f in str_fs:
if src_is_array:
eh_dict[str_f][slidx] = split_value_dict[str_f]
else:
eh_dict[str_f][slidx] = value
setf.set_fields(value)
for str_f in str_fs:
cl.enqueue_copy(fields.queue, gpu_eh, fields.get_buf(str_f))
self.assertEqual(
np.abs(eh_dict[str_f] - gpu_eh).max(), 0, self.args)
def runTest(self):
if len(self.args) == 6:
nx, ny, nz, str_f, pt0, pt1 = self.args
src_is_array = False
elif len(self.args) == 7:
nx, ny, nz, str_f, pt0, pt1, src_is_array = self.args
slidx = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '')
setf = SetFields(fields, str_f, pt0, pt1, src_is_array)
# generate random source
if src_is_array:
shape = list( common.shape_two_points(pt0, pt1) )
shape[0] *= len(str_fs)
value = np.random.rand(*shape).astype(fields.dtype)
split_value = np.split(value, len(str_fs))
split_value_dict = dict( zip(str_fs, split_value) )
else:
value = np.random.ranf()
# host allocations
eh_dict = {}
for sf in str_fs:
eh_dict[sf] = np.zeros(fields.ns, dtype=fields.dtype)
gpu_eh = np.zeros(fields.ns, dtype=fields.dtype)
# verify
for str_f in str_fs:
if src_is_array:
eh_dict[str_f][slidx] = split_value_dict[str_f]
else:
eh_dict[str_f][slidx] = value
setf.set_fields(value)
for str_f in str_fs:
cl.enqueue_copy(fields.queue, gpu_eh, fields.get_buf(str_f))
self.assertEqual(np.abs(eh_dict[str_f] - gpu_eh).max(), 0, self.args)
def runTest(self):
nx, ny, nz, str_f, pt0, pt1 = self.args
slices = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
mainf_list = [gpu.Fields(context, device, nx, ny, nz) \
for device in gpu_devices]
mainf_list.append(cpu.Fields(nx, ny, nz))
nodef = NodeFields(mainf_list)
dtype = nodef.dtype
anx = nodef.accum_nx_list
getf = NodeGetFields(nodef, str_f, pt0, pt1)
# generate random source
global_ehs = [np.zeros(nodef.ns, dtype) for i in range(6)]
eh_dict = dict(zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], global_ehs))
for i, f in enumerate(mainf_list[:-1]):
nx, ny, nz = f.ns
ehs = common_update.generate_random_ehs(nx, ny, nz, dtype)
f.set_eh_bufs(*ehs)
for eh, geh in zip(ehs, global_ehs):
geh[anx[i]:anx[i + 1], :, :] = eh[:-1, :, :]
f = mainf_list[-1]
nx, ny, nz = f.ns
ehs = common_update.generate_random_ehs(nx, ny, nz, dtype)
f.set_ehs(*ehs)
for eh, geh in zip(ehs, global_ehs):
geh[anx[-2]:anx[-1] + 1, :, :] = eh[:]
# verify
getf.wait()
for str_f in str_fs:
original = eh_dict[str_f][slices]
copy = getf.get_fields(str_f)
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1 = self.args
slices = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
mainf_list = [gpu.Fields(context, device, nx, ny, nz) \
for device in gpu_devices]
mainf_list.append( cpu.Fields(nx, ny, nz) )
nodef = NodeFields(mainf_list)
dtype = nodef.dtype
anx = nodef.accum_nx_list
getf = NodeGetFields(nodef, str_f, pt0, pt1)
# generate random source
global_ehs = [np.zeros(nodef.ns, dtype) for i in range(6)]
eh_dict = dict( zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], global_ehs) )
for i, f in enumerate(mainf_list[:-1]):
nx, ny, nz = f.ns
ehs = common_update.generate_random_ehs(nx, ny, nz, dtype)
f.set_eh_bufs(*ehs)
for eh, geh in zip(ehs, global_ehs):
geh[anx[i]:anx[i+1],:,:] = eh[:-1,:,:]
f = mainf_list[-1]
nx, ny, nz = f.ns
ehs = common_update.generate_random_ehs(nx, ny, nz, dtype)
f.set_ehs(*ehs)
for eh, geh in zip(ehs, global_ehs):
geh[anx[-2]:anx[-1]+1,:,:] = eh[:]
# verify
getf.wait()
for str_f in str_fs:
original = eh_dict[str_f][slices]
copy = getf.get_fields(str_f)
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array = self.args
slices = common.slice_index_two_points(pt0, pt1)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1)
value = np.random.rand(*shape).astype(np.float32)
else:
value = np.random.ranf()
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
mainf_list = [gpu.Fields(context, device, nx, ny, nz) \
for device in gpu_devices]
mainf_list.append( cpu.Fields(nx, ny, nz) )
nodef = NodeFields(mainf_list)
dtype = nodef.dtype
anx = nodef.accum_nx_list
tfunc = lambda tstep: np.sin(0.03*tstep)
incident = NodeDirectIncident(nodef, str_f, pt0, pt1, tfunc, value)
# allocations for verify
eh = np.zeros(nodef.ns, dtype)
getf = NodeGetFields(nodef, str_f, pt0, pt1)
# verify
eh[slices] = dtype(value) * dtype(tfunc(1))
e_or_h = str_f[0]
nodef.update_e()
nodef.update_h()
getf.wait()
original = eh[slices]
copy = getf.get_fields(str_f)
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array = self.args
slidx = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '', 'single')
setf = SetFields(fields, str_f, pt0, pt1, is_array)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1, len(str_fs))
value = np.random.rand(*shape).astype(fields.dtype)
split_value = np.split(value, len(str_fs))
split_value_dict = dict( zip(str_fs, split_value) )
else:
value = np.random.ranf()
# host allocations
ehs = [np.zeros(fields.ns, dtype=fields.dtype) for i in range(6)]
eh_dict = dict( zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], ehs) )
gpu_eh = np.zeros(fields.ns_pitch, dtype=fields.dtype)
# verify
for str_f in str_fs:
if is_array:
eh_dict[str_f][slidx] = split_value_dict[str_f]
else:
eh_dict[str_f][slidx] = value
setf.set_fields(value)
for str_f in str_fs:
cl.enqueue_copy(fields.queue, gpu_eh, fields.get_buf(str_f))
original = eh_dict[str_f]
copy = gpu_eh[:,:,fields.slice_z]
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array = self.args
slidx = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '', 'single')
setf = SetFields(fields, str_f, pt0, pt1, is_array)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1, len(str_fs))
value = np.random.rand(*shape).astype(fields.dtype)
split_value = np.split(value, len(str_fs))
split_value_dict = dict(zip(str_fs, split_value))
else:
value = np.random.ranf()
# host allocations
ehs = [np.zeros(fields.ns, dtype=fields.dtype) for i in range(6)]
eh_dict = dict(zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], ehs))
gpu_eh = np.zeros(fields.ns_pitch, dtype=fields.dtype)
# verify
for str_f in str_fs:
if is_array:
eh_dict[str_f][slidx] = split_value_dict[str_f]
else:
eh_dict[str_f][slidx] = value
setf.set_fields(value)
for str_f in str_fs:
cl.enqueue_copy(fields.queue, gpu_eh, fields.get_buf(str_f))
original = eh_dict[str_f]
copy = gpu_eh[:, :, fields.slice_z]
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array = self.args
slices = common.slice_index_two_points(pt0, pt1)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1)
value = np.random.rand(*shape).astype(np.float32)
else:
value = np.random.ranf()
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
mainf_list = [gpu.Fields(context, device, nx, ny, nz) \
for device in gpu_devices]
mainf_list.append(cpu.Fields(nx, ny, nz))
nodef = NodeFields(mainf_list)
dtype = nodef.dtype
anx = nodef.accum_nx_list
tfunc = lambda tstep: np.sin(0.03 * tstep)
incident = NodeDirectIncident(nodef, str_f, pt0, pt1, tfunc, value)
# allocations for verify
eh = np.zeros(nodef.ns, dtype)
getf = NodeGetFields(nodef, str_f, pt0, pt1)
# verify
eh[slices] = dtype(value) * dtype(tfunc(1))
e_or_h = str_f[0]
nodef.update_e()
nodef.update_h()
getf.wait()
original = eh[slices]
copy = getf.get_fields(str_f)
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def __init__(self,
fields,
str_f,
pt0,
pt1,
is_array=False,
is_overwrite=True):
"""
"""
common.check_type('fields', fields, Fields)
common.check_type('str_f', str_f, (str, list, tuple), str)
common.check_type('pt0', pt0, (list, tuple), int)
common.check_type('pt1', pt1, (list, tuple), int)
common.check_type('is_array', is_array, bool)
common.check_type('is_overwrite', is_overwrite, bool)
# local variables
str_fs = common.convert_to_tuple(str_f)
for strf in str_fs:
strf_list = ['ex', 'ey', 'ez', 'hx', 'hy', 'hz']
common.check_value('str_f', strf, strf_list)
for axis, n, p0, p1 in zip(['x', 'y', 'z'], fields.ns, pt0, pt1):
common.check_value('pt0 %s' % axis, p0, range(n))
common.check_value('pt1 %s' % axis, p1, range(n))
# global variables and functions
self.mainf = fields
self.str_fs = str_fs
self.slice_xyz = common.slice_index_two_points(pt0, pt1)
self.shape = common.shape_two_points(pt0, pt1, len(str_fs))
self.is_overwrite = is_overwrite
if is_array:
self.func = self.set_fields_spatial_value
else:
self.func = self.set_fields_single_value
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array = self.args
slice_xyz = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
fields = Fields(nx, ny, nz, '', 'single')
setf = SetFields(fields, str_f, pt0, pt1, is_array)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1, len(str_fs))
value = np.random.rand(*shape).astype(fields.dtype)
split_value = np.split(value, len(str_fs))
split_value_dict = dict(zip(str_fs, split_value))
else:
value = np.random.ranf()
# host allocations
ehs = [np.zeros(fields.ns, dtype=fields.dtype) for i in range(6)]
eh_dict = dict(zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], ehs))
# verify
for str_f in str_fs:
if is_array:
eh_dict[str_f][slice_xyz] = split_value_dict[str_f]
else:
eh_dict[str_f][slice_xyz] = value
setf.set_fields(value)
fields.enqueue_barrier()
for str_f in str_fs:
original = eh_dict[str_f]
copy = fields.get(str_f)[:, :, fields.slice_z]
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array = self.args
slice_xyz = common.slice_index_two_points(pt0, pt1)
str_fs = common.convert_to_tuple(str_f)
# instance
fields = Fields(nx, ny, nz, '', 'single')
setf = SetFields(fields, str_f, pt0, pt1, is_array)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1, len(str_fs))
value = np.random.rand(*shape).astype(fields.dtype)
split_value = np.split(value, len(str_fs))
split_value_dict = dict( zip(str_fs, split_value) )
else:
value = np.random.ranf()
# host allocations
ehs = [np.zeros(fields.ns, dtype=fields.dtype) for i in range(6)]
eh_dict = dict( zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], ehs) )
# verify
for str_f in str_fs:
if is_array:
eh_dict[str_f][slice_xyz] = split_value_dict[str_f]
else:
eh_dict[str_f][slice_xyz] = value
setf.set_fields(value)
fields.enqueue_barrier()
for str_f in str_fs:
original = eh_dict[str_f]
copy = fields.get(str_f)[:,:,fields.slice_z]
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array = self.args
slice_xyz = common.slice_index_two_points(pt0, pt1)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1)
value = np.random.rand(*shape).astype(np.float32)
else:
value = np.random.ranf()
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '', 'single')
tfunc = lambda tstep: np.sin(0.03 * tstep)
incident = DirectIncident(fields, str_f, pt0, pt1, tfunc, value)
# host allocations
eh = np.zeros(fields.ns_pitch, dtype=fields.dtype)
# verify
eh[slice_xyz] = fields.dtype(value) * fields.dtype(tfunc(1))
fields.update_e()
fields.update_h()
copy_eh_buf = fields.get_buf(str_f)
copy_eh = np.zeros_like(eh)
cl.enqueue_copy(fields.queue, copy_eh, copy_eh_buf)
original = eh[slice_xyz]
copy = copy_eh[slice_xyz]
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
def runTest(self):
nx, ny, nz, str_f, pt0, pt1, is_array = self.args
slice_xyz = common.slice_index_two_points(pt0, pt1)
# generate random source
if is_array:
shape = common.shape_two_points(pt0, pt1)
value = np.random.rand(*shape).astype(np.float32)
else:
value = np.random.ranf()
# instance
gpu_devices = common_gpu.gpu_device_list(print_info=False)
context = cl.Context(gpu_devices)
device = gpu_devices[0]
fields = Fields(context, device, nx, ny, nz, '', 'single')
tfunc = lambda tstep: np.sin(0.03*tstep)
incident = DirectIncident(fields, str_f, pt0, pt1, tfunc, value)
# host allocations
eh = np.zeros(fields.ns_pitch, dtype=fields.dtype)
# verify
eh[slice_xyz] = fields.dtype(value) * fields.dtype(tfunc(1))
fields.update_e()
fields.update_h()
copy_eh_buf = fields.get_buf(str_f)
copy_eh = np.zeros_like(eh)
cl.enqueue_copy(fields.queue, copy_eh, copy_eh_buf)
original = eh[slice_xyz]
copy = copy_eh[slice_xyz]
norm = np.linalg.norm(original - copy)
self.assertEqual(norm, 0, '%s, %g' % (self.args, norm))
