def runTest(self): ufunc, nx, ny, nz, coeff_use, precision_float, tmax = self.args fields = gpu.Fields(0, nx, ny, nz, coeff_use, precision_float) gpu.Core(fields) fields_ref = naive.Fields(nx, ny, nz, precision_float, segment_nbytes=64) naive.Core(fields_ref) # allocations ns = fields.ns dtype = fields.dtype strf_list = ['ex', 'ey', 'ez', 'hx', 'hy', 'hz'] ehs = common_random.generate_ehs(nx, ny, nz, dtype, ufunc) fields.set_eh_bufs(*ehs) fields_ref.set_ehs(*ehs) ces, chs = common_random.generate_cs(nx, ny, nz, dtype, coeff_use) if 'e' in coeff_use: fields.set_ce_bufs(*ces) fields_ref.set_ces(*ces) if 'h' in coeff_use: fields.set_ch_bufs(*chs) fields_ref.set_chs(*chs) tmpf = np.zeros(fields.ns_pitch, dtype=dtype) # update if ufunc == 'e': for tstep in xrange(0, tmax): fields.update_e() fields_ref.update_e() for strf, eh in zip(strf_list, ehs)[:3]: cuda.memcpy_dtoh(tmpf, fields.get_buf(strf)) norm = np.linalg.norm(fields_ref.get(strf) - tmpf) max_diff = np.abs(fields_ref.get(strf) - tmpf).max() self.assertEqual( norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff)) elif ufunc == 'h': for tstep in xrange(0, tmax): fields.update_h() fields_ref.update_h() for strf, eh in zip(strf_list, ehs)[3:]: cuda.memcpy_dtoh(tmpf, fields.get_buf(strf)) norm = np.linalg.norm(fields_ref.get(strf) - tmpf) max_diff = np.abs(fields_ref.get(strf) - tmpf).max() self.assertEqual( norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff)) fields.context.pop()
def runTest(self): nx, ny, nz, str_f, pt0, pt1 = self.args slidx = common.slices_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_random.generate_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): ufunc, nx, ny, nz, coeff_use, precision_float, use_cpu_core, tmax = self.args qtask = cpu.QueueTask() fields = cpu.Fields(qtask, nx, ny, nz, coeff_use, precision_float, use_cpu_core) cpu.Core(fields) fields_ref = naive.Fields(nx, ny, nz, precision_float, segment_nbytes=16) naive.Core(fields_ref) # allocations ns = fields.ns dtype = fields.dtype ehs = common_random.generate_ehs(nx, ny, nz, dtype, ufunc) fields.set_ehs(*ehs) fields_ref.set_ehs(*ehs) ces, chs = common_random.generate_cs(nx, ny, nz, dtype, coeff_use) if 'e' in coeff_use: fields.set_ces(*ces) fields_ref.set_ces(*ces) if 'h' in coeff_use: fields.set_chs(*chs) fields_ref.set_chs(*chs) # verify strf_list = ['ex', 'ey', 'ez', 'hx', 'hy', 'hz'] if ufunc == 'e': for tstep in xrange(0, tmax): fields.update_e() fields_ref.update_e() fields.enqueue_barrier() for strf, eh in zip(strf_list, ehs)[:3]: norm = np.linalg.norm(fields.get(strf) - fields_ref.get(strf)) max_diff = np.abs(fields.get(strf) - fields_ref.get(strf)).max() self.assertEqual( norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff)) elif ufunc == 'h': for tstep in xrange(0, tmax): fields.update_h() fields_ref.update_h() fields.enqueue_barrier() for strf, eh in zip(strf_list, ehs)[3:]: norm = np.linalg.norm(fields.get(strf) - fields_ref.get(strf)) max_diff = np.abs(fields.get(strf) - fields_ref.get(strf)).max() self.assertEqual(norm, 0, '%s, %s, %g, %g' % \ (self.args, strf, norm, max_diff) )
def runTest(self): ufunc, nx, ny, nz, coeff_use, precision_float, tmax = self.args gpu_devices = common_gpu.gpu_device_list(print_info=False) context = cl.Context(gpu_devices) device = gpu_devices[0] fields = gpu.Fields(context, device, nx, ny, nz, coeff_use, precision_float) gpu.Core(fields) fields_ref = naive.Fields(nx, ny, nz, precision_float) naive.Core(fields_ref) # allocations ns = fields.ns dtype = fields.dtype strf_list = ['ex', 'ey', 'ez', 'hx', 'hy', 'hz'] ehs = common_random.generate_ehs(nx, ny, nz, dtype, ufunc) fields.set_eh_bufs(*ehs) fields_ref.set_ehs(*ehs) ces, chs = common_random.generate_cs(nx, ny, nz, dtype, coeff_use) if 'e' in coeff_use: fields.set_ce_bufs(*ces) fields_ref.set_ces(*ces) if 'h' in coeff_use: fields.set_ch_bufs(*chs) fields_ref.set_chs(*chs) tmpf = np.zeros(fields.ns, dtype=dtype) # update if ufunc == 'e': for tstep in xrange(0, tmax): fields.update_e() fields_ref.update_e() for strf, eh in zip(strf_list, ehs)[:3]: cl.enqueue_copy(fields.queue, tmpf, fields.get_buf(strf)) norm = np.linalg.norm(fields_ref.get(strf) - tmpf) max_diff = np.abs(fields_ref.get(strf) - tmpf).max() self.assertEqual( norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff)) elif ufunc == 'h': for tstep in xrange(0, tmax): fields.update_h() fields_ref.update_h() for strf, eh in zip(strf_list, ehs)[3:]: cl.enqueue_copy(fields.queue, tmpf, fields.get_buf(strf)) norm = np.linalg.norm(fields_ref.get(strf) - tmpf) max_diff = np.abs(fields_ref.get(strf) - tmpf).max() self.assertEqual( norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff))
def runTest(self): nx, ny, nz, str_f, pt0, pt1 = self.args slices = common.slices_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 = Fields(mainf_list) dtype = nodef.dtype anx = nodef.accum_nx_list getf = GetFields(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_random.generate_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_random.generate_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.slices_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 = Fields(mainf_list) dtype = nodef.dtype anx = nodef.accum_nx_list getf = GetFields(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_random.generate_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_random.generate_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): ufunc, nx, ny, nz, coeff_use, precision_float, tmax = self.args gpu_devices = common_gpu.gpu_device_list(print_info=False) context = cl.Context(gpu_devices) device = gpu_devices[0] qtask = cpu.QueueTask() fields = gpu.Fields(context, device, qtask, nx, ny, nz, coeff_use, precision_float) gpu.Core(fields) fields_ref = naive.Fields(nx, ny, nz, precision_float, segment_nbytes=64) naive.Core(fields_ref) # allocations ns = fields.ns dtype = fields.dtype strf_list = ['ex', 'ey', 'ez', 'hx', 'hy', 'hz'] ehs = common_random.generate_ehs(nx, ny, nz, dtype, ufunc) fields.set_eh_bufs(*ehs) fields_ref.set_ehs(*ehs) ces, chs = common_random.generate_cs(nx, ny, nz, dtype, coeff_use) if 'e' in coeff_use: fields.set_ce_bufs(*ces) fields_ref.set_ces(*ces) if 'h' in coeff_use: fields.set_ch_bufs(*chs) fields_ref.set_chs(*chs) tmpf = np.zeros(fields.ns_pitch, dtype=dtype) # update if ufunc == 'e': for tstep in xrange(0, tmax): fields.update_e() fields_ref.update_e() qtask.enqueue_barrier() for strf, eh in zip(strf_list, ehs)[:3]: cl.enqueue_copy(fields.queue, tmpf, fields.get_buf(strf)) norm = np.linalg.norm(fields_ref.get(strf) - tmpf) max_diff = np.abs(fields_ref.get(strf) - tmpf).max() self.assertEqual(norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff) ) elif ufunc == 'h': for tstep in xrange(0, tmax): fields.update_h() fields_ref.update_h() for strf, eh in zip(strf_list, ehs)[3:]: cl.enqueue_copy(fields.queue, tmpf, fields.get_buf(strf)) norm = np.linalg.norm(fields_ref.get(strf) - tmpf) max_diff = np.abs(fields_ref.get(strf) - tmpf).max() self.assertEqual(norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff) )
def runTest(self): ufunc, nx, ny, nz, coeff_use, precision_float, use_cpu_core, tmax = self.args qtask = cpu.QueueTask() fields = cpu.Fields(qtask, nx, ny, nz, coeff_use, precision_float, use_cpu_core) cpu.Core(fields) fields_ref = naive.Fields(nx, ny, nz, precision_float, segment_nbytes=16) naive.Core(fields_ref) # allocations ns = fields.ns dtype = fields.dtype ehs = common_random.generate_ehs(nx, ny, nz, dtype, ufunc) fields.set_ehs(*ehs) fields_ref.set_ehs(*ehs) ces, chs = common_random.generate_cs(nx, ny, nz, dtype, coeff_use) if 'e' in coeff_use: fields.set_ces(*ces) fields_ref.set_ces(*ces) if 'h' in coeff_use: fields.set_chs(*chs) fields_ref.set_chs(*chs) # verify strf_list = ['ex', 'ey', 'ez', 'hx', 'hy', 'hz'] if ufunc == 'e': for tstep in xrange(0, tmax): for instance in fields.instance_list: instance.update_e('pre') instance.update_e('post') fields_ref.update_e() fields.enqueue_barrier() for strf, eh in zip(strf_list, ehs)[:3]: norm = np.linalg.norm(fields.get(strf) - fields_ref.get(strf)) max_diff = np.abs(fields.get(strf) - fields_ref.get(strf)).max() self.assertEqual(norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff) ) elif ufunc == 'h': for tstep in xrange(0, tmax): for instance in fields.instance_list: instance.update_h('pre') instance.update_h('post') fields_ref.update_h() fields.enqueue_barrier() for strf, eh in zip(strf_list, ehs)[3:]: norm = np.linalg.norm(fields.get(strf) - fields_ref.get(strf)) max_diff = np.abs(fields.get(strf) - fields_ref.get(strf)).max() self.assertEqual(norm, 0, '%s, %s, %g, %g' % \ (self.args, strf, norm, max_diff) )
def runTest(self): ufunc, nx, ny, nz, coeff_use, precision_float, tmax = self.args fields = gpu.Fields(0, nx, ny, nz, coeff_use, precision_float) gpu.Core(fields) fields_ref = naive.Fields(nx, ny, nz, precision_float, segment_nbytes=64) naive.Core(fields_ref) # allocations ns = fields.ns dtype = fields.dtype strf_list = ['ex', 'ey', 'ez', 'hx', 'hy', 'hz'] ehs = common_random.generate_ehs(nx, ny, nz, dtype, ufunc) fields.set_eh_bufs(*ehs) fields_ref.set_ehs(*ehs) ces, chs = common_random.generate_cs(nx, ny, nz, dtype, coeff_use) if 'e' in coeff_use: fields.set_ce_bufs(*ces) fields_ref.set_ces(*ces) if 'h' in coeff_use: fields.set_ch_bufs(*chs) fields_ref.set_chs(*chs) tmpf = np.zeros(fields.ns_pitch, dtype=dtype) # update if ufunc == 'e': for tstep in xrange(0, tmax): fields.update_e() fields_ref.update_e() for strf, eh in zip(strf_list, ehs)[:3]: cuda.memcpy_dtoh(tmpf, fields.get_buf(strf)) norm = np.linalg.norm(fields_ref.get(strf) - tmpf) max_diff = np.abs(fields_ref.get(strf) - tmpf).max() self.assertEqual(norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff) ) elif ufunc == 'h': for tstep in xrange(0, tmax): fields.update_h() fields_ref.update_h() for strf, eh in zip(strf_list, ehs)[3:]: cuda.memcpy_dtoh(tmpf, fields.get_buf(strf)) norm = np.linalg.norm(fields_ref.get(strf) - tmpf) max_diff = np.abs(fields_ref.get(strf) - tmpf).max() self.assertEqual(norm, 0, '%s, %s, %g, %g' % (self.args, strf, norm, max_diff) ) fields.context.pop()
def runTest(self): nx, ny, nz, str_f, pt0, pt1 = self.args slice_xyz = common.slices_two_points(pt0, pt1) str_fs = common.convert_to_tuple(str_f) # instance fields = Fields(nx, ny, nz, '', 'single') getf = GetFields(fields, str_f, pt0, pt1) # host allocations ehs = common_random.generate_ehs(nx, ny, nz, fields.dtype) eh_dict = dict( zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], ehs) ) fields.set_ehs(*ehs) # verify getf.get_event().wait() for str_f in str_fs: original = eh_dict[str_f][slice_xyz] 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 slice_xyz = common.slices_two_points(pt0, pt1) str_fs = common.convert_to_tuple(str_f) # instance fields = Fields(nx, ny, nz, '', 'single') getf = GetFields(fields, str_f, pt0, pt1) # host allocations ehs = common_random.generate_ehs(nx, ny, nz, fields.dtype) eh_dict = dict(zip(['ex', 'ey', 'ez', 'hx', 'hy', 'hz'], ehs)) fields.set_ehs(*ehs) # verify getf.get_event().wait() for str_f in str_fs: original = eh_dict[str_f][slice_xyz] 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 = self.args # instances buffer_dict = {} buffer_dict['x+'] = cpu.BufferFields('x+', ny, nz, '', 'single') buffer_dict['x-'] = cpu.BufferFields('x-', ny, nz, '', 'single') import pyopencl as cl from kemp.fdtd3d.util import common_gpu from kemp.fdtd3d import gpu gpu_devices = common_gpu.gpu_device_list(print_info=False) context = cl.Context(gpu_devices) mainf_list = [ gpu.Fields(context, gpu_devices[0], nx, ny, nz) ] #mainf_list = [ cpu.Fields(nx, ny, nz) ] nodef = node.Fields(mainf_list, buffer_dict) # generate random source dtype = nodef.dtype ehs = common_random.generate_ehs(nx, ny, nz, dtype) buf_ehs_p = common_random.generate_ehs(3, ny, nz, dtype) buf_ehs_m = common_random.generate_ehs(3, ny, nz, dtype) nodef.mainf_list[0].set_eh_bufs(*ehs) #nodef.mainf_list[0].set_ehs(*ehs) nodef.buffer_dict['x+'].set_ehs(*buf_ehs_p) nodef.buffer_dict['x-'].set_ehs(*buf_ehs_m) node.Core(nodef) # allocations for verify getf_dict = {'x+': {}, 'x-': {}} getf_buf_dict = {'x+': {}, 'x-': {}} getf_dict['x+']['e'] = gpu.GetFields(nodef.mainf_list[0], ['ey', 'ez'], (nx-1, 0, 0), (nx-1, ny-1, nz-1)) getf_dict['x+']['h'] = gpu.GetFields(nodef.mainf_list[0], ['hy', 'hz'], (nx-2, 0, 0), (nx-2, ny-1, nz-1)) getf_buf_dict['x+']['e'] = cpu.GetFields(nodef.buffer_dict['x+'], ['ey', 'ez'], (1, 0, 0), (1, ny-1, nz-1)) getf_buf_dict['x+']['h'] = cpu.GetFields(nodef.buffer_dict['x+'], ['hy', 'hz'], (0, 0, 0), (0, ny-1, nz-1)) getf_dict['x-']['e'] = gpu.GetFields(nodef.mainf_list[0], ['ey', 'ez'], (1, 0, 0), (1, ny-1, nz-1)) getf_dict['x-']['h'] = gpu.GetFields(nodef.mainf_list[0], ['hy', 'hz'], (0, 0, 0), (0, ny-1, nz-1)) getf_buf_dict['x-']['e'] = cpu.GetFields(nodef.buffer_dict['x-'], ['ey', 'ez'], (2, 0, 0), (2, ny-1, nz-1)) getf_buf_dict['x-']['h'] = cpu.GetFields(nodef.buffer_dict['x-'], ['hy', 'hz'], (1, 0, 0), (1, ny-1, nz-1)) # verify nodef.update_e() nodef.update_h() print 'nodef, instance_list', nodef.instance_list print 'mainf_list[0], instance_list', nodef.mainf_list[0].instance_list for direction in ['x+', 'x-']: for e_or_h in ['e', 'h']: getf = getf_dict[direction][e_or_h] getf_buf = getf_buf_dict[direction][e_or_h] getf.get_event().wait() getf_buf.get_event().wait() original = getf.get_fields() copy = getf_buf.get_fields() norm = np.linalg.norm(original - copy) self.assertEqual(norm, 0, '%s, %g, %s, %s' % (self.args, norm, direction, e_or_h))
def runTest(self): nx, ny, nz = self.args tmax = 10 # instances buffer_dict = {} if rank == 0: buffer_dict['x+'] = cpu.BufferFields('x+', ny, nz, '', 'single') elif rank == 1: buffer_dict['x-'] = cpu.BufferFields('x-', ny, nz, '', 'single') import pyopencl as cl from kemp.fdtd3d.util import common_gpu from kemp.fdtd3d import gpu gpu_devices = common_gpu.gpu_device_list(print_info=False) context = cl.Context(gpu_devices) mainf_list = [ gpu.Fields(context, gpu_devices[0], nx, ny, nz) ] #mainf_list = [ cpu.Fields(nx, ny, nz, use_cpu_core=1) ] nodef = node.Fields(mainf_list, buffer_dict) # generate random source dtype = nodef.dtype ehs = common_random.generate_ehs(nx, ny, nz, dtype) buf_ehs = common_random.generate_ehs(3, ny, nz, dtype) #nodef.cpuf.set_ehs(*ehs) nodef.mainf_list[0].set_eh_bufs(*ehs) other = {0: 1, 1: 0}[rank] if rank == 0: #nodef.buffer_dict['x+'].set_ehs(*buf_ehs) ExchangeMpi(nodef.buffer_dict['x+'], other, tmax) elif rank == 1: #nodef.buffer_dict['x-'].set_ehs(*buf_ehs) ExchangeMpi(nodef.buffer_dict['x-'], other, tmax) node.Core(nodef) # allocations for verify if rank == 0: getf_e = cpu.GetFields(nodef.buffer_dict['x+'], ['ey', 'ez'], (2, 0, 0), (2, ny-1, nz-1)) getf_h = cpu.GetFields(nodef.buffer_dict['x+'], ['hy', 'hz'], (1, 0, 0), (1, ny-1, nz-1)) elif rank == 1: getf_e = cpu.GetFields(nodef.buffer_dict['x-'], ['ey', 'ez'], (1, 0, 0), (1, ny-1, nz-1)) getf_h = cpu.GetFields(nodef.buffer_dict['x-'], ['hy', 'hz'], (0, 0, 0), (0, ny-1, nz-1)) # verify print 'nodef, instance_list', rank, nodef.instance_list print 'f0, instance_list', rank, nodef.mainf_list[0].instance_list exch = nodef.instance_list[0] main_core = nodef.mainf_list[0].instance_list[0] if rank == 0: #nodef.buffer_dict['x+'].instance_list.pop(0) print 'bufferf x+, instance_list', rank, nodef.buffer_dict['x+'].instance_list core, mpi = nodef.buffer_dict['x+'].instance_list elif rank == 1: #nodef.buffer_dict['x-'].instance_list.pop(0) print 'bufferf x-, instance_list', rank, nodef.buffer_dict['x-'].instance_list core, mpi = nodef.buffer_dict['x-'].instance_list for tstep in xrange(1, tmax+1): #if rank == 0: print 'tstep', tstep #nodef.update_e() main_core.update_e() if rank == 0: #print tstep, rank, 'core upE' core.update_e('') #print tstep, rank, 'mpi upE' mpi.update_e('') elif rank == 1: #print tstep, rank, 'core upE pre' core.update_e('pre') #print tstep, rank, 'mpi upE pre' mpi.update_e('pre') #print tstep, rank, 'core upE post' core.update_e('post') #print tstep, rank, 'mpi upE post' mpi.update_e('post') exch.update_e() # verify the buffer #print tstep, rank, 'pre get' getf_h.get_event().wait() #print tstep, rank, 'after get' if rank == 1: #print tstep, rank, 'pre save' np.save('rank1_h_%d' % tstep, getf_h.get_fields()) #print tstep, rank, 'after save' elif rank == 0: no_exist_npy = True while no_exist_npy: try: arr1 = np.load('rank1_h_%d.npy' % tstep) no_exist_npy = False except: sleep(0.5) arr0 = getf_h.get_fields() #print tstep, 'h arr0\n', arr0 #print tstep, 'h arr1\n', arr1 norm = np.linalg.norm(arr0 - arr1) if norm != 0: print tstep, 'h norm', norm #if tstep > 1: self.assertEqual(norm, 0, '%s, %g, h' % (self.args, norm)) #nodef.update_h() main_core.update_h() if rank == 0: #print tstep, rank, 'core upH pre' core.update_h('pre') #print tstep, rank, 'mpi upH pre' mpi.update_h('pre') #print tstep, rank, 'core upH post' core.update_h('post') #print tstep, rank, 'mpi upH post' mpi.update_h('post') elif rank == 1: #print tstep, rank, 'core upH' core.update_h('') #print tstep, rank, 'mpi upH' mpi.update_h('') exch.update_h() getf_e.get_event().wait() if rank == 1: np.save('rank1_e_%d' % tstep, getf_e.get_fields()) elif rank == 0: no_exist_npy = True while no_exist_npy: try: arr1 = np.load('rank1_e_%d.npy' % tstep) no_exist_npy = False except: sleep(0.5) arr0 = getf_e.get_fields() norm = np.linalg.norm(arr0 - arr1) if norm != 0: print tstep, 'e norm', norm #self.assertEqual(norm, 0, '%s, %g, e' % (self.args, norm)) '''