Rename permuted_matrix_sequence

python/dune/codegen/sumfact/accumulation.py

@@ -126,11 +126,11 @@ class AccumulationOutput(SumfactKernelInterfaceBase, ImmutableRecord):
     def realize(self, sf, result, insn_dep, inames=None, additional_inames=()):
         trial_leaf_element = get_leaf(self.trial_element, self.trial_element_index) if self.trial_element is not None else None
 
-        basis_size = tuple(mat.basis_size for mat in sf.permuted_matrix_sequence)
+        basis_size = tuple(mat.basis_size for mat in sf.matrix_sequence_quadrature_permuted)
 
         if inames is None:
             inames = tuple(accum_iname(trial_leaf_element, mat.rows, i)
-                           for i, mat in enumerate(sf.permuted_matrix_sequence))
+                           for i, mat in enumerate(sf.matrix_sequence_quadrature_permuted))
 
             # Determine the expression to accumulate with. This depends on the vectorization strategy!
             from dune.codegen.tools import maybe_wrap_subscript

python/dune/codegen/sumfact/basis.py

@@ -89,7 +89,7 @@ class LFSSumfactKernelInput(SumfactKernelInterfaceBase, ImmutableRecord):
         from dune.codegen.sumfact.realization import name_buffer_storage
         name = "input_{}".format(sf.buffer)
         temporary_variable(name,
-                           shape=(product(mat.basis_size for mat in sf.permuted_matrix_sequence), sf.vector_width),
+                           shape=(product(mat.basis_size for mat in sf.matrix_sequence_quadrature_permuted), sf.vector_width),
                            custom_base_storage=name_buffer_storage(sf.buffer, 0),
                            managed=True,
                            )

python/dune/codegen/sumfact/permutation.py

@@ -52,7 +52,7 @@ def sumfact_permutation_strategy(sf):
     heuristic is used to pick one.
     """
     # Extract information from the SumfactKernel object
-    matrix_sequence = sf.permuted_matrix_sequence
+    matrix_sequence = sf.matrix_sequence_quadrature_permuted
     stage = sf.stage
 
     # Combine permutation and matrix_sequence

python/dune/codegen/sumfact/realization.py

@@ -76,8 +76,8 @@ def _realize_sum_factorization_kernel(sf):
     for buf in buffers:
         # Determine the necessary size of the buffer. We assume that we do not
         # underintegrate the form!!!
-        size = max(product(m.quadrature_size for m in sf.permuted_matrix_sequence) * sf.vector_width,
-                   product(m.basis_size for m in sf.permuted_matrix_sequence) * sf.vector_width)
+        size = max(product(m.quadrature_size for m in sf.matrix_sequence_quadrature_permuted) * sf.vector_width,
+                   product(m.basis_size for m in sf.matrix_sequence_quadrature_permuted) * sf.vector_width)
         temporary_variable("{}_dummy".format(buf),
                            shape=(size,),
                            custom_base_storage=buf,
@@ -164,7 +164,7 @@ def realize_sumfact_kernel_function(sf):
     perm = sumfact_permutation_strategy(sf)
 
     # Permute matrix sequence
-    matrix_sequence = permute_forward(sf.permuted_matrix_sequence, perm)
+    matrix_sequence = permute_forward(sf.matrix_sequence_quadrature_permuted, perm)
 
     # Product of all matrices
     for l, matrix in enumerate(matrix_sequence):
@@ -215,7 +215,7 @@ def realize_sumfact_kernel_function(sf):
                 inp_shape = permute_backward(inp_shape, perm)
                 input_inames = permute_backward(input_inames, perm)
                 if sf.stage == 1:
-                    # In the unstructured case the sf.permuted_matrix_sequence could
+                    # In the unstructured case the sf.matrix_sequence_quadrature_permuted could
                     # already be permuted according to
                     # sf.quadrature_permutation. We also need to reverse this
                     # permutation to get the input from 0 to d-1.

python/dune/codegen/sumfact/symbolic.py

@@ -163,7 +163,7 @@ class VectorSumfactKernelOutput(SumfactKernelInterfaceBase):
         from dune.codegen.sumfact.accumulation import accum_iname
         element = get_leaf(trial_element, trial_element_index) if trial_element is not None else None
         inames = tuple(accum_iname(element, mat.rows, i)
-                       for i, mat in enumerate(sf.permuted_matrix_sequence))
+                       for i, mat in enumerate(sf.matrix_sequence_quadrature_permuted))
         veciname = accum_iname(element, sf.vector_width // len(outputs), "vec")
         transform(lp.tag_inames, [(veciname, "vec")])
 
@@ -344,10 +344,10 @@ class SumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable):
         return lp.symbolic.StringifyMapper
 
     def __str__(self):
-        # Return permuted_matrix_sequence
+        # Return matrix_sequence_quadrature_permuted
         return "SF{}:[{}]->[{}]".format(self.stage,
                                         str(self.interface),
-                                        ", ".join(str(m) for m in self.permuted_matrix_sequence))
+                                        ", ".join(str(m) for m in self.matrix_sequence_quadrature_permuted))
 
     mapper_method = "map_sumfact_kernel"
 
@@ -358,9 +358,9 @@ class SumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable):
     @property
     def function_name(self):
         """ The name of the function that implements this kernel """
-        # Use permuted_matrix_sequence here since this is more consistent with
+        # Use matrix_sequence_quadrature_permuted here since this is more consistent with
         # the vectorized case
-        name = "sfimpl_{}{}".format("_".join(str(m) for m in self.permuted_matrix_sequence),
+        name = "sfimpl_{}{}".format("_".join(str(m) for m in self.matrix_sequence_quadrature_permuted),
                                     self.interface.function_name_suffix)
 
         # On unstructured we need different permutation of the input to realize
@@ -379,7 +379,7 @@ class SumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable):
         # TODO: For now we do not vectorize SumfactKernels with different
         # quadrature_permutation. This should be handled like upper/lower
         # vectorization
-        return self.quadrature_permutation + tuple(m.basis_size for m in self.permuted_matrix_sequence) + (self.stage, self.buffer, self.interface.within_inames)
+        return self.quadrature_permutation + tuple(m.basis_size for m in self.matrix_sequence_quadrature_permuted) + (self.stage, self.buffer, self.interface.within_inames)
 
     @property
     def cache_key(self):
@@ -444,7 +444,7 @@ class SumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable):
         return 0
 
     @property
-    def permuted_matrix_sequence(self):
+    def matrix_sequence_quadrature_permuted(self):
         """Matrix sequence ordered according to desired quadrature point ordered
 
         Except for face integrals on 3D unstructured grids this will just be
@@ -453,8 +453,8 @@ class SumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable):
         and neighbor.
         """
         perm = self.quadrature_permutation
-        permuted_matrix_sequence = permute_forward(self.matrix_sequence, perm)
-        return permuted_matrix_sequence
+        matrix_sequence_quadrature_permuted = permute_forward(self.matrix_sequence, perm)
+        return matrix_sequence_quadrature_permuted
 
     @property
     def quadrature_shape(self):
@@ -462,7 +462,7 @@ class SumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable):
 
         Takes into account the lower dimensionality of faces and vectorization.
         """
-        return tuple(mat.quadrature_size for mat in self.permuted_matrix_sequence)
+        return tuple(mat.quadrature_size for mat in self.matrix_sequence_quadrature_permuted)
 
     def quadrature_index(self, sf, visitor):
         if visitor.current_info[1] is None:
@@ -475,14 +475,14 @@ class SumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable):
                 element = element.extract_component(element_index)[1]
 
         quad_inames = quadrature_inames(element)
-        if len(self.permuted_matrix_sequence) == local_dimension():
+        if len(self.matrix_sequence_quadrature_permuted) == local_dimension():
             return tuple(prim.Variable(i) for i in quad_inames)
 
         # Traverse all the quadrature inames and map them to their correct direction
         index = []
         i = 0
         for d in range(world_dimension()):
-            if self.permuted_matrix_sequence[d].face is None:
+            if self.matrix_sequence_quadrature_permuted[d].face is None:
                 index.append(prim.Variable(quad_inames[i]))
                 i = i + 1
             else:
@@ -505,7 +505,7 @@ class SumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable):
 
         Takes into account vectorization.
         """
-        return tuple(mat.basis_size for mat in self.permuted_matrix_sequence)
+        return tuple(mat.basis_size for mat in self.matrix_sequence_quadrature_permuted)
 
     @property
     def dof_dimtags(self):
@@ -611,10 +611,10 @@ class VectorizedSumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable)
 
         # Assert properties of the matrix sequence of the underlying kernels
         for i in range(kernels[0].length):
-            assert len(set(tuple(k.permuted_matrix_sequence[i].rows for k in kernels))) == 1
-            assert len(set(tuple(k.permuted_matrix_sequence[i].cols for k in kernels))) == 1
-            assert len(set(tuple(k.permuted_matrix_sequence[i].direction for k in kernels))) == 1
-            assert len(set(tuple(k.permuted_matrix_sequence[i].transpose for k in kernels))) == 1
+            assert len(set(tuple(k.matrix_sequence_quadrature_permuted[i].rows for k in kernels))) == 1
+            assert len(set(tuple(k.matrix_sequence_quadrature_permuted[i].cols for k in kernels))) == 1
+            assert len(set(tuple(k.matrix_sequence_quadrature_permuted[i].direction for k in kernels))) == 1
+            assert len(set(tuple(k.matrix_sequence_quadrature_permuted[i].transpose for k in kernels))) == 1
 
         # Join the instruction dependencies of all subkernels
         insn_dep = insn_dep.union(k.insn_dep for k in kernels)
@@ -674,13 +674,13 @@ class VectorizedSumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable)
     #
     @property
     def matrix_sequence(self):
-        return tuple(BasisTabulationMatrixArray(tuple(k.permuted_matrix_sequence[i] for k in self.kernels),
+        return tuple(BasisTabulationMatrixArray(tuple(k.matrix_sequence_quadrature_permuted[i] for k in self.kernels),
                                                 width=self.vector_width,
                                                 )
                      for i in range(self.length))
 
     @property
-    def permuted_matrix_sequence(self):
+    def matrix_sequence_quadrature_permuted(self):
         return self.matrix_sequence
 
     @property
@@ -752,7 +752,7 @@ class VectorizedSumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable)
     def horizontal_index(self, sf):
         for i, k in enumerate(self.kernels):
             if sf.inout_key == k.inout_key:
-                if tuple(mat.derivative for mat in sf.permuted_matrix_sequence) == tuple(mat.derivative for mat in k.permuted_matrix_sequence):
+                if tuple(mat.derivative for mat in sf.matrix_sequence_quadrature_permuted) == tuple(mat.derivative for mat in k.matrix_sequence_quadrature_permuted):
                     return i
 
         return 0
@@ -807,7 +807,7 @@ class VectorizedSumfactKernel(SumfactKernelBase, ImmutableRecord, prim.Variable)
 
         quad_inames = quadrature_inames(element)
         sliced = 0
-        if len(sf.permuted_matrix_sequence) == local_dimension():
+        if len(sf.matrix_sequence_quadrature_permuted) == local_dimension():
             for d in range(local_dimension()):
                 if self.matrix_sequence[d].slice_size:
                     sliced = prim.Variable(quad_inames[d])

python/dune/codegen/sumfact/vectorization.py

@@ -313,7 +313,7 @@ def level1_optimal_vectorization_strategy(sumfacts, width):
         sf = next(iter(sumfacts))
         depth = 1
         while depth <= width:
-            i = 0 if sf.permuted_matrix_sequence[0].face is None else 1
+            i = 0 if sf.matrix_sequence_quadrature_permuted[0].face is None else 1
             quad = list(quadrature_points_per_direction())
             quad[i] = round_to_multiple(quad[i], depth)
             quad_points.append(tuple(quad))
@@ -449,14 +449,14 @@ def get_vectorization_dict(sumfacts, vertical, horizontal, qp):
             continue
 
         # Determine the slicing direction
-        slice_direction = 0 if sf.permuted_matrix_sequence[0].face is None else 1
+        slice_direction = 0 if sf.matrix_sequence_quadrature_permuted[0].face is None else 1
         if qp[slice_direction] % vertical != 0:
             return None
 
         # Split the basis tabulation matrices
-        oldtab = sf.permuted_matrix_sequence[slice_direction]
+        oldtab = sf.matrix_sequence_quadrature_permuted[slice_direction]
         for i in range(vertical):
-            seq = list(sf.permuted_matrix_sequence)
+            seq = list(sf.matrix_sequence_quadrature_permuted)
             seq[slice_direction] = oldtab.copy(slice_size=vertical,
                                                slice_index=i)
             kernels.append(sf.copy(matrix_sequence=tuple(seq)))