示例#1
0
    def __init__(self, fields, axes):
        """
        """

        common.check_type('fields', fields, Fields)
        common.check_type('axes', axes, str)

        assert len(set(axes).intersection(
            set('xyz'))) > 0, 'axes option is wrong: %s is given' % repr(axes)

        # local variables
        nx, ny, nz = fields.ns
        dtype_str_list = fields.dtype_str_list

        # program
        macros = ['NMAX', 'IDX0', 'IDX1', 'DTYPE', 'PRAGMA_fp64']

        program_dict = {}
        gs_dict = {}
        for axis in list(axes):
            program_dict[axis] = {}

            for e_or_h in ['e', 'h']:
                pt0 = common_exchange.pt0_dict(nx, ny, nz)[axis][e_or_h]['get']
                pt1 = common_exchange.pt1_dict(nx, ny, nz)[axis][e_or_h]['get']
                nmaxi_str, xid_str, yid_str, zid_str = common_gpu.macro_replace_list(
                    pt0, pt1)
                idx0_str = '%s*ny*nz + %s*nz + %s' % (xid_str, yid_str,
                                                      zid_str)

                pt0 = common_exchange.pt0_dict(nx, ny, nz)[axis][e_or_h]['set']
                pt1 = common_exchange.pt1_dict(nx, ny, nz)[axis][e_or_h]['set']
                nmax_str, xid_str, yid_str, zid_str = common_gpu.macro_replace_list(
                    pt0, pt1)
                idx1_str = '%s*ny*nz + %s*nz + %s' % (xid_str, yid_str,
                                                      zid_str)

                values = [nmax_str, idx0_str, idx1_str] + dtype_str_list

                ksrc = common.replace_template_code( \
                        open(common_gpu.src_path + 'copy_self.cl').read(), \
                        macros, values)
                program = cl.Program(fields.context, ksrc).build()
                program_dict[axis][e_or_h] = program

            nmax = int(nmax_str)
            remainder = nmax % fields.ls
            gs_dict[
                axis] = nmax if remainder == 0 else nmax - remainder + fields.ls

        # global variables
        self.mainf = fields
        self.axes = axes
        self.program_dict = program_dict
        self.gs_dict = gs_dict

        # append to the update list
        self.priority_type = 'pbc'
        self.mainf.append_instance(self)
示例#2
0
    def __init__(self, fields, axes):
        """
        """

        common.check_type('fields', fields, Fields)
        common.check_type('axes', axes, str)

        assert len( set(axes).intersection(set('xyz')) ) > 0, 'axes option is wrong: %s is given' % repr(axes)

        # local variables
        nx, ny, nz = fields.ns
        dtype_str_list = fields.dtype_str_list

        # program
        macros = ['NMAX', 'IDX0', 'IDX1', 'DTYPE', 'PRAGMA_fp64']

        program_dict = {}
        gs_dict = {}
        for axis in list(axes):
            program_dict[axis] = {}

            for e_or_h in ['e', 'h']:
                pt0 = common_exchange.pt0_dict(nx, ny, nz)[axis][e_or_h]['get']
                pt1 = common_exchange.pt1_dict(nx, ny, nz)[axis][e_or_h]['get']
                nmaxi_str, xid_str, yid_str, zid_str = common_gpu.macro_replace_list(pt0, pt1)
                idx0_str = '%s*ny*nz + %s*nz + %s' % (xid_str, yid_str, zid_str)

                pt0 = common_exchange.pt0_dict(nx, ny, nz)[axis][e_or_h]['set']
                pt1 = common_exchange.pt1_dict(nx, ny, nz)[axis][e_or_h]['set']
                nmax_str, xid_str, yid_str, zid_str = common_gpu.macro_replace_list(pt0, pt1)
                idx1_str = '%s*ny*nz + %s*nz + %s' % (xid_str, yid_str, zid_str)

                values = [nmax_str, idx0_str, idx1_str] + dtype_str_list

                ksrc = common.replace_template_code( \
                        open(common_gpu.src_path + 'copy_self.cl').read(), \
                        macros, values)
                program = cl.Program(fields.context, ksrc).build()
                program_dict[axis][e_or_h] = program

            nmax = int(nmax_str)
            remainder = nmax % fields.ls
            gs_dict[axis] = nmax if remainder == 0 else nmax - remainder + fields.ls 

        # global variables
        self.mainf = fields
        self.axes = axes
        self.program_dict = program_dict
        self.gs_dict = gs_dict

        # append to the update list
        self.priority_type = 'pbc'
        self.mainf.append_instance(self)
示例#3
0
    def __init__(self, fields, axes):
        """
        """

        common.check_type("fields", fields, Fields)
        common.check_type("axes", axes, str)

        assert len(set(axes).intersection(set("xyz"))) > 0, "axes option is wrong: %s is given" % repr(axes)

        # local variables
        nx, ny, nz = fields.ns
        dtype_str_list = fields.dtype_str_list

        # program
        macros = ["NMAX", "IDX0", "IDX1", "DTYPE", "PRAGMA_fp64"]

        program_dict = {}
        for axis in list(axes):
            program_dict[axis] = {}

            for e_or_h in ["e", "h"]:
                pt0 = common_exchange.pt0_dict(nx, ny, nz)[axis][e_or_h]["get"]
                pt1 = common_exchange.pt1_dict(nx, ny, nz)[axis][e_or_h]["get"]
                nmax, xid, yid, zid = common_gpu.macro_replace_list(pt0, pt1)
                idx0_str = "%s*ny*nz + %s*nz + %s" % (xid, yid, zid)

                pt0 = common_exchange.pt0_dict(nx, ny, nz)[axis][e_or_h]["set"]
                pt1 = common_exchange.pt1_dict(nx, ny, nz)[axis][e_or_h]["set"]
                nmax, xid, yid, zid = common_gpu.macro_replace_list(pt0, pt1)
                idx1_str = "%s*ny*nz + %s*nz + %s" % (xid, yid, zid)

                values = [nmax, idx0_str, idx1_str] + dtype_str_list

                ksrc = common.replace_template_code(open(common_gpu.src_path + "copy_self.cl").read(), macros, values)
                program = cl.Program(fields.context, ksrc).build()
                program_dict[axis][e_or_h] = program

        # global variables
        self.mainf = fields
        self.axes = axes
        self.program_dict = program_dict

        # append to the update list
        self.priority_type = "pbc"
        self.mainf.append_instance(self)
    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, float))
        common.check_type('pt1', pt1, (list, tuple), (int, float))

        pt0 = list(common.convert_indices(fields.ns, pt0))
        pt1 = list(common.convert_indices(fields.ns, pt1))

        # local variables
        str_fs = common.convert_to_tuple(str_f)
        dtype_str_list = fields.dtype_str_list

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

        # program
        macros = ['NMAX', 'XID', 'YID', 'ZID', \
                'ARGS', \
                'TARGET', 'SOURCE', 'OVERWRITE', \
                'DTYPE']

        values = common_gpu.macro_replace_list(pt0, pt1) + \
                ['DTYPE *source', \
                'target[sub_idx]', 'source[idx]', '='] + \
                dtype_str_list

        ksrc = common.replace_template_code( \
                open(common_gpu.src_path + 'copy.cu').read(), macros, values)
        program = SourceModule(ksrc)
        kernel_copy = program.get_function('copy')

        # allocation
        source_bufs = [fields.get_buf(str_f) for str_f in str_fs]
        shape = common.shape_two_points(pt0, pt1, len(str_fs))

        host_array = np.zeros(shape, fields.dtype)
        split_host_array = np.split(host_array, len(str_fs))
        split_host_array_dict = dict(zip(str_fs, split_host_array))
        target_buf = cuda.to_device(host_array)

        # global variables
        self.mainf = fields
        self.kernel_copy = kernel_copy
        self.source_bufs = source_bufs
        self.target_buf = target_buf
        self.host_array = host_array
        self.split_host_array_dict = split_host_array_dict
示例#5
0
    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, float))
        common.check_type('pt1', pt1, (list, tuple), (int, float))

        pt0 = list( common.convert_indices(fields.ns, pt0) )
        pt1 = list( common.convert_indices(fields.ns, pt1) )

        # local variables
        str_fs = common.convert_to_tuple(str_f)
        dtype_str_list = fields.dtype_str_list

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

        # program
        macros = ['NMAX', 'XID', 'YID', 'ZID', \
                'ARGS', \
                'TARGET', 'SOURCE', 'OVERWRITE', \
                'DTYPE']

        values = common_gpu.macro_replace_list(pt0, pt1) + \
                ['DTYPE *source', \
                'target[sub_idx]', 'source[idx]', '='] + \
                dtype_str_list

        ksrc = common.replace_template_code( \
                open(common_gpu.src_path + 'copy.cu').read(), macros, values)
        program = SourceModule(ksrc)
        kernel_copy = program.get_function('copy')

        # allocation
        source_bufs = [fields.get_buf(str_f) for str_f in str_fs]
        shape = common.shape_two_points(pt0, pt1, len(str_fs))

        host_array = np.zeros(shape, fields.dtype)
        split_host_array = np.split(host_array, len(str_fs))
        split_host_array_dict = dict( zip(str_fs, split_host_array) ) 
        target_buf = cuda.to_device(host_array)

        # global variables
        self.mainf = fields
        self.kernel_copy = kernel_copy
        self.source_bufs = source_bufs
        self.target_buf = target_buf
        self.host_array = host_array
        self.split_host_array_dict = split_host_array_dict
    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)
        dtype_str_list = fields.dtype_str_list

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

        # program
        macros = ['NMAX', 'XID', 'YID', 'ZID', \
                'ARGS', \
                'TARGET', 'SOURCE', 'OVERWRITE', \
                'DTYPE', 'PRAGMA_fp64']

        values = common_gpu.macro_replace_list(pt0, pt1) + \
                ['__global DTYPE *source', \
                'target[sub_idx]', 'source[idx]', '='] + \
                dtype_str_list

        ksrc = common.replace_template_code( \
                open(common_gpu.src_path + 'copy.cl').read(), macros, values)
        program = cl.Program(fields.context, ksrc).build()

        # allocation
        source_bufs = [fields.get_buf(str_f) for str_f in str_fs]
        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))

        target_buf = cl.Buffer( \
                fields.context, \
                cl.mem_flags.READ_WRITE | cl.mem_flags.COPY_HOST_PTR, \
                hostbuf=host_array)

        # global variables
        self.mainf = fields
        self.program = program
        self.source_bufs = source_bufs
        self.target_buf = target_buf
        self.host_array = host_array
        self.split_host_array_dict = split_host_array_dict
示例#7
0
    def __init__(self, fields, axis):
        """
        """

        common.check_type('fields', fields, Fields)
        common.check_value('axis', axis, ['x', 'y', 'z'])

        # local variables
        nx, ny, nz = fields.ns
        dtype_str_list = fields.dtype_str_list

        # program
        replace = lambda lst, idx, val: lst[:idx] + [val] + lst[idx+1:]

        base0 = {'e': [0, 0, 0], 'h': [1, 1, 1]}
        base1 = {'e': [nx-2, ny-2, nz-2], 'h': [nx-1, ny-1, nz-1]}
        axis_id = {'x':0, 'y':1, 'z':2}[axis]
        nn = fields.ns[axis_id]

        value_dict = {'e': [], 'h': []}
        for eh in ['e', 'h']:
            for idx in {'e': [0, nn-1], 'h':[nn-1, 0]}[eh]:
                pt0 = replace(base0[eh], axis_id, idx)
                pt1 = replace(base1[eh], axis_id, idx)
                nmax, xid, yid, zid = \
                        common_gpu.macro_replace_list(pt0, pt1)

                value_dict[eh].append( \
                        '%s*ny*nz + %s*nz + %s' % (xid, yid, zid) )

        macros = ['NMAX', 'IDX0', 'IDX1', 'DTYPE', 'PRAGMA_fp64']
        values_e = [nmax] + value_dict['e'] + dtype_str_list
        values_h = [nmax] + value_dict['h'] + dtype_str_list

        ksrc_e = common.replace_template_code( \
                open(common_gpu.src_path + 'copy_self.cl').read(), \
                macros, values_e)
        ksrc_h = common.replace_template_code( \
                open(common_gpu.src_path + 'copy_self.cl').read(), \
                macros, values_h)
        program_e = cl.Program(fields.context, ksrc_e).build()
        program_h = cl.Program(fields.context, ksrc_h).build()

        # global variables
        self.mainf = fields
        self.program_e = program_e
        self.program_h = program_h

        self.strfs_e = {'x':['ey','ez'], 'y':['ex','ez'], 'z':['ex','ey']}[axis]
        self.strfs_h = {'x':['hy','hz'], 'y':['hx','hz'], 'z':['hx','hy']}[axis]

        # append to the update list
        self.priority_type = 'pbc'
        self.mainf.append_instance(self)
示例#8
0
    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)
        dtype_str_list = fields.dtype_str_list

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

        # program
        macros = ["NMAX", "XID", "YID", "ZID", "ARGS", "TARGET", "SOURCE", "OVERWRITE", "DTYPE", "PRAGMA_fp64"]

        values = (
            common_gpu.macro_replace_list(pt0, pt1)
            + ["__global DTYPE *source", "target[sub_idx]", "source[idx]", "="]
            + dtype_str_list
        )

        ksrc = common.replace_template_code(open(common_gpu.src_path + "copy.cl").read(), macros, values)
        program = cl.Program(fields.context, ksrc).build()

        # allocation
        source_bufs = [fields.get_buf(str_f) for str_f in str_fs]
        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))

        target_buf = cl.Buffer(fields.context, cl.mem_flags.READ_WRITE | cl.mem_flags.COPY_HOST_PTR, hostbuf=host_array)

        # global variables
        self.mainf = fields
        self.program = program
        self.source_bufs = source_bufs
        self.target_buf = target_buf
        self.host_array = host_array
        self.split_host_array_dict = split_host_array_dict
    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, float))
        common.check_type('pt1', pt1, (list, tuple), (int, float))
        common.check_type('is_array', is_array, bool)
        common.check_type('is_overwrite', is_overwrite, bool)

        pt0 = list(common.convert_indices(fields.ns, pt0))
        pt1 = list(common.convert_indices(fields.ns, pt1))

        # local variables
        str_fs = common.convert_to_tuple(str_f)
        dtype_str_list = fields.dtype_str_list
        overwrite_str = {True: '=', False: '+='}[is_overwrite]

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

# program
        macros = ['NMAX', 'XID', 'YID', 'ZID', \
                'ARGS', \
                'TARGET', 'SOURCE', 'OVERWRITE', \
                'DTYPE']

        if is_array:
            values = common_gpu.macro_replace_list(pt0, pt1) + \
                    ['DTYPE *source', \
                    'target[idx]', 'source[sub_idx]', overwrite_str] + \
                    dtype_str_list
        else:
            values = common_gpu.macro_replace_list(pt0, pt1) + \
                    ['DTYPE source', \
                    'target[idx]', 'source', overwrite_str] + \
                    dtype_str_list

        ksrc = common.replace_template_code( \
                open(common_gpu.src_path + 'copy.cu').read(), macros, values)
        program = SourceModule(ksrc)
        kernel_copy = program.get_function('copy')

        # allocation
        target_bufs = [fields.get_buf(str_f) for str_f in str_fs]
        shape = common.shape_two_points(pt0, pt1, len(str_fs))

        if is_array:
            tmp_array = np.zeros(shape, fields.dtype)
            source_buf = cuda.to_device(tmp_array)

        # global variabels and functions
        self.mainf = fields
        self.kernel_copy = kernel_copy
        self.target_bufs = target_bufs
        self.shape = shape

        if is_array:
            self.source_buf = source_buf
            self.set_fields = self.set_fields_spatial_value
        else:
            self.set_fields = self.set_fields_single_value
示例#10
0
    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, float))
        common.check_type('pt1', pt1, (list, tuple), (int, float))
        common.check_type('is_array', is_array, bool)
        common.check_type('is_overwrite', is_overwrite, bool)

        pt0 = list( common.convert_indices(fields.ns, pt0) )
        pt1 = list( common.convert_indices(fields.ns, pt1) )

        # local variables
        str_fs = common.convert_to_tuple(str_f)
        dtype_str_list = fields.dtype_str_list
        overwrite_str = {True: '=', False: '+='}[is_overwrite]

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

		# program
        macros = ['NMAX', 'XID', 'YID', 'ZID', \
                'ARGS', \
                'TARGET', 'SOURCE', 'OVERWRITE', \
                'DTYPE']

        if is_array:
            values = common_gpu.macro_replace_list(pt0, pt1) + \
                    ['DTYPE *source', \
                    'target[idx]', 'source[sub_idx]', overwrite_str] + \
                    dtype_str_list
        else:
            values = common_gpu.macro_replace_list(pt0, pt1) + \
                    ['DTYPE source', \
                    'target[idx]', 'source', overwrite_str] + \
                    dtype_str_list

        ksrc = common.replace_template_code( \
                open(common_gpu.src_path + 'copy.cu').read(), macros, values)
        program = SourceModule(ksrc)
        kernel_copy = program.get_function('copy')

		# allocation
        target_bufs = [fields.get_buf(str_f) for str_f in str_fs]
        shape = common.shape_two_points(pt0, pt1, len(str_fs))

        if is_array:
            tmp_array = np.zeros(shape, fields.dtype)
            source_buf = cuda.to_device(tmp_array)

        # global variabels and functions
        self.mainf = fields
        self.kernel_copy = kernel_copy
        self.target_bufs = target_bufs
        self.shape = shape

        if is_array:
            self.source_buf = source_buf
            self.set_fields = self.set_fields_spatial_value
        else:
            self.set_fields = self.set_fields_single_value
示例#11
0
    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, float))
        common.check_type('pt1', pt1, (list, tuple), (int, float))
        common.check_type('is_array', is_array, bool)
        common.check_type('is_overwrite', is_overwrite, bool)

        pt0 = list( common.convert_indices(fields.ns, pt0) )
        pt1 = list( common.convert_indices(fields.ns, pt1) )

        # local variables
        str_fs = common.convert_to_tuple(str_f)
        dtype_str_list = fields.dtype_str_list
        overwrite_str = {True: '=', False: '+='}[is_overwrite]

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

        # program
        macros = ['NMAX', 'XID', 'YID', 'ZID', \
                  'ARGS', \
                  'TARGET', 'SOURCE', 'OVERWRITE', \
                  'DTYPE', 'PRAGMA_fp64']

        nmax_str, xid_str, yid_str, zid_str = common_gpu.macro_replace_list(pt0, pt1)
        if is_array:
            values = [nmax_str, xid_str, yid_str, zid_str, \
                      '__global DTYPE *source', \
                      'target[idx]', 'source[sub_idx]', overwrite_str] + \
                dtype_str_list
        else:
            values = [nmax_str, xid_str, yid_str, zid_str, \
                      'DTYPE source', \
                      'target[idx]', 'source', overwrite_str] + \
                dtype_str_list

        ksrc = common.replace_template_code( \
            open(common_gpu.src_path + 'copy.cl').read(), macros, values)
        program = cl.Program(fields.context, ksrc).build()

        # allocation
        target_bufs = [fields.get_buf(str_f) for str_f in str_fs]
        shape = common.shape_two_points(pt0, pt1, len(str_fs))

        if is_array:
            tmp_array = np.zeros(shape, dtype=fields.dtype)
            source_buf = cl.Buffer( \
                fields.context, \
                cl.mem_flags.READ_WRITE | cl.mem_flags.COPY_HOST_PTR, \
                hostbuf=tmp_array)

        # global variabels and functions
        self.mainf = fields
        self.program = program
        self.target_bufs = target_bufs
        self.shape = shape

        nmax = int(nmax_str)
        remainder = nmax % fields.ls
        self.gs = nmax if remainder == 0 else nmax - remainder + fields.ls 

        if is_array:
            self.source_buf = source_buf
            self.set_fields = self.set_fields_spatial_value
        else:
            self.set_fields = self.set_fields_single_value
示例#12
0
    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, float))
        common.check_type('pt1', pt1, (list, tuple), (int, float))
        common.check_type('is_array', is_array, bool)
        common.check_type('is_overwrite', is_overwrite, bool)

        pt0 = list( common.convert_indices(fields.ns, pt0) )
        pt1 = list( common.convert_indices(fields.ns, pt1) )

        # local variables
        str_fs = common.convert_to_tuple(str_f)
        dtype_str_list = fields.dtype_str_list
        overwrite_str = {True: '=', False: '+='}[is_overwrite]

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

		# program
        macros = ['NMAX', 'XID', 'YID', 'ZID', \
                'ARGS', \
                'TARGET', 'SOURCE', 'OVERWRITE', \
                'DTYPE', 'PRAGMA_fp64']

        nmax_str, xid_str, yid_str, zid_str = common_gpu.macro_replace_list(pt0, pt1)
        if is_array:
            values = [nmax_str, xid_str, yid_str, zid_str, \
                    '__global DTYPE *source', \
                    'target[idx]', 'source[sub_idx]', overwrite_str] + \
                    dtype_str_list
        else:
            values = [nmax_str, xid_str, yid_str, zid_str, \
                    'DTYPE source', \
                    'target[idx]', 'source', overwrite_str] + \
                    dtype_str_list

        ksrc = common.replace_template_code( \
                open(common_gpu.src_path + 'copy.cl').read(), macros, values)
        program = cl.Program(fields.context, ksrc).build()

		# allocation
        target_bufs = [fields.get_buf(str_f) for str_f in str_fs]
        shape = common.shape_two_points(pt0, pt1, len(str_fs))

        if is_array:
            tmp_array = np.zeros(shape, dtype=fields.dtype) 
            source_buf = cl.Buffer( \
                    fields.context, \
                    cl.mem_flags.READ_WRITE | cl.mem_flags.COPY_HOST_PTR, \
                    hostbuf=tmp_array)

        # global variabels and functions
        self.mainf = fields
        self.program = program
        self.target_bufs = target_bufs
        self.shape = shape

        nmax = int(nmax_str)
        remainder = nmax % fields.ls
        self.gs = nmax if remainder == 0 else nmax - remainder + fields.ls 

        if is_array:
            self.source_buf = source_buf
            self.set_fields = self.set_fields_spatial_value
        else:
            self.set_fields = self.set_fields_single_value
示例#13
0
    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)
        dtype_str_list = fields.dtype_str_list
        overwrite_str = {True: "=", False: "+="}[is_overwrite]

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

        # program
        macros = ["NMAX", "XID", "YID", "ZID", "ARGS", "TARGET", "SOURCE", "OVERWRITE", "DTYPE", "PRAGMA_fp64"]

        if is_array:
            values = (
                common_gpu.macro_replace_list(pt0, pt1)
                + ["__global DTYPE *source", "target[idx]", "source[sub_idx]", overwrite_str]
                + dtype_str_list
            )
        else:
            values = (
                common_gpu.macro_replace_list(pt0, pt1)
                + ["DTYPE source", "target[idx]", "source", overwrite_str]
                + dtype_str_list
            )

        ksrc = common.replace_template_code(open(common_gpu.src_path + "copy.cl").read(), macros, values)
        program = cl.Program(fields.context, ksrc).build()

        # allocation
        target_bufs = [fields.get_buf(str_f) for str_f in str_fs]
        shape = common.shape_two_points(pt0, pt1, len(str_fs))

        if is_array:
            tmp_array = np.zeros(shape, dtype=fields.dtype)
            source_buf = cl.Buffer(
                fields.context, cl.mem_flags.READ_WRITE | cl.mem_flags.COPY_HOST_PTR, hostbuf=tmp_array
            )

        # global variabels and functions
        self.mainf = fields
        self.program = program
        self.target_bufs = target_bufs
        self.shape = shape

        if is_array:
            self.source_buf = source_buf
            self.set_fields = self.set_fields_spatial_value
        else:
            self.set_fields = self.set_fields_single_value
示例#14
0
    def __init__(self,
                 fields,
                 pt0,
                 pt1,
                 ep_inf,
                 drude_freq,
                 gamma,
                 mask_arrays=(1, 1, 1)):
        common.check_type('fields', fields, Fields)
        common.check_type('pt0', pt0, (list, tuple), (int, float))
        common.check_type('pt1', pt1, (list, tuple), (int, float))
        common.check_type('ep_inf', ep_inf, (int, float))
        common.check_type('drude_freq', drude_freq, (int, float))
        common.check_type('gamma', gamma, (int, float))
        common.check_type('mask_arrays', mask_arrays, (list, tuple),
                          (np.ndarray, int))

        # local variables
        pt0 = common.convert_indices(fields.ns, pt0)
        pt1 = common.convert_indices(fields.ns, pt1)
        context = fields.context
        queue = fields.queue
        dtype = fields.dtype
        shape = common.shape_two_points(pt0, pt1, is_dummy=True)

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

        for mask_array in mask_arrays:
            if isinstance(mask_array, np.ndarray):
                assert common.shape_two_points(pt0, pt1) == mask_array.shape, \
                       'shape mismatch : %s, %s' % (shape, mask_array.shape)

        # allocations
        psis = [np.zeros(shape, dtype) for i in range(3)]
        psi_bufs = [
            cl.Buffer(context, cl.mem_flags.READ_WRITE, psi.nbytes)
            for psi in psis
        ]
        for psi_buf, psi in zip(psi_bufs, psis):
            cl.enqueue_copy(queue, psi_buf, psi)

        dt = fields.dt
        aa = (2 - gamma * dt) / (2 + gamma * dt)
        bb = drude_freq**2 * dt / (2 + gamma * dt)
        comm = 2 * ep_inf + bb * dt
        ca = 2 * dt / comm
        cb = -(aa + 3) * bb * dt / comm
        cc = -(aa + 1) * dt / comm
        cas = [ca * mask for mask in mask_arrays]

        shape = common.shape_two_points(pt0, pt1, is_dummy=True)
        f = np.zeros(shape, dtype)
        psi_bufs = [
            cl.Buffer(context, cl.mem_flags.READ_WRITE, f.nbytes)
            for i in range(3)
        ]
        for psi_buf in psi_bufs:
            cl.enqueue_copy(queue, psi_buf, f)

        cf = np.ones(shape, dtype)
        mask_bufs = [
            cl.Buffer(context, cl.mem_flags.READ_ONLY, cf.nbytes)
            for i in range(3)
        ]
        for mask_buf, mask in zip(mask_bufs, mask_arrays):
            cl.enqueue_copy(queue, mask_buf, cf * mask)

        # modify ce arrays
        slices = common.slices_two_points(pt0, pt1)
        for ce, ca in zip(fields.get_ces(), cas):
            ce[slices] = ca * mask + ce[slices] * mask.__invert__()

        # program
        nmax_str, xid_str, yid_str, zid_str = common_gpu.macro_replace_list(
            pt0, pt1)
        macros = ['NMAX', 'XID', 'YID', 'ZID', 'DX', 'DTYPE', 'PRAGMA_fp64']
        values = [nmax_str, xid_str, yid_str, zid_str,
                  str(fields.ls)] + fields.dtype_str_list

        ksrc = common.replace_template_code( \
            open(common_gpu.src_path + 'drude.cl').read(), macros, values)
        program = cl.Program(fields.context, ksrc).build()

        # arguments
        pca = aa
        pcb = (aa + 1) * bb
        args = fields.ns + [dtype(cb), dtype(cc), dtype(pca), dtype(pcb)] \
            + fields.eh_bufs[:3] + psi_bufs + mask_bufs

        # global variables
        self.mainf = fields
        self.program = program
        self.args = args

        nx, ny, nz = fields.ns
        nmax = int(nmax_str)
        remainder = nmax % fields.ls
        self.gs = nmax if remainder == 0 else nmax - remainder + fields.ls

        # append to the update list
        self.priority_type = 'material'
        fields.append_instance(self)