Example #1
0
    def test_2d_map(self, backend):
        # copy/adapted from test_indirect_loop
        nedges = nelems - 1
        nodes = op2.Set(nelems, 1, "nodes")
        edges = op2.Set(nedges, 1, "edges")
        node_vals = op2.Dat(nodes, numpy.array(range(nelems), dtype=numpy.uint32), numpy.uint32, "node_vals")
        edge_vals = op2.Dat(edges, numpy.array([0] * nedges, dtype=numpy.uint32), numpy.uint32, "edge_vals")

        e_map = numpy.array([(i, i+1) for i in range(nedges)], dtype=numpy.uint32)
        edge2node = op2.Map(edges, nodes, 2, e_map, "edge2node")

        kernel_sum = """
        void kernel_sum(unsigned int *nodes1, unsigned int *nodes2, unsigned int *edge)
        { *edge = *nodes1 + *nodes2; }
        """

        kernel = op2.Kernel(kernel_sum, "kernel_sum")

        device.compare_plans(kernel,
                             edges,
                             node_vals(edge2node[0], op2.READ),
                             node_vals(edge2node[1], op2.READ),
                             edge_vals(op2.IdentityMap, op2.WRITE),
                             matrix_coloring=False,
                             partition_size=96)
Example #2
0
 def test_rhs(self, backend):
     kernel = op2.Kernel("", "dummy")
     elements = op2.Set(2, 1, "elements")
     nodes = op2.Set(4, 1, "nodes")
     vnodes = op2.Set(4, 2, "vnodes")
     elem_node = op2.Map(elements, nodes, 3,
                         numpy.asarray([ 0, 1, 3, 2, 3, 1 ],
                                       dtype=numpy.uint32),
                         "elem_node")
     b = op2.Dat(nodes, numpy.asarray([0.0]*4, dtype=numpy.float64),
                 numpy.float64, "b")
     coords = op2.Dat(vnodes,
                      numpy.asarray([(0.0, 0.0), (2.0, 0.0),
                                     (1.0, 1.0), (0.0, 1.5)],
                                    dtype=numpy.float64),
                      numpy.float64, "coords")
     f = op2.Dat(nodes,
                 numpy.asarray([ 1.0, 2.0, 3.0, 4.0 ], dtype=numpy.float64),
                 numpy.float64, "f")
     device.compare_plans(kernel,
                          elements,
                          b(elem_node[0], op2.INC),
                          b(elem_node[1], op2.INC),
                          b(elem_node[2], op2.INC),
                          coords(elem_node[0], op2.READ),
                          coords(elem_node[1], op2.READ),
                          coords(elem_node[2], op2.READ),
                          f(elem_node[0], op2.READ),
                          f(elem_node[1], op2.READ),
                          f(elem_node[2], op2.READ),
                          matrix_coloring=False,
                          partition_size=2)
Example #3
0
    def test_onecolor_wo(self, backend, iterset, x, iterset2indset):
        # copy/adapted from test_indirect_loop
        kernel_wo = "void kernel_wo(unsigned int* x) { *x = 42; }\n"

        kernel = op2.Kernel(kernel_wo, "kernel_wo")

        device.compare_plans(kernel,
                             iterset,
                             x(iterset2indset[0], op2.WRITE),
                             partition_size=128,
                             matrix_coloring=False)