merge test works

test/test_templating.py

@@ -12,9 +12,6 @@ class Base_Check(object):
         self.assertTrue(len(templates), len(self._instances))
         for template, inst in zip(templates, self._instances):
             cut = merged.cut(template)
-            print([inst, merged, template, cut])
-            print()
-            print([inst.maps, merged.maps, template.maps, cut.maps])
             self.demand_equal_cut(inst, template, cut)
 
     def demand_equal_cut(self, inst, template, cut):
@@ -42,16 +39,13 @@ class TensorMaps_Empty_Test(Base_Check, unittest.TestCase):
         for mp_dim, mp in inst.maps.items():
             cut_map = cut.maps[mp_dim]
             template_map = template.maps[mp_dim]
-            print(mp, ',', cut_map, ',', template_map)
             self.assertEqual(len(mp),
                              len(cut_map))
             self.assertEqual(tfields.dim(mp),
                              tfields.dim(cut_map))
             self.assertEqual(tfields.dim(template_map),
                              tfields.dim(cut_map))
-        self.assertTrue(tfields.TensorFields(inst).equal(
-                        tfields.TensorFields(cut)))
-        self.assertTrue(inst.equal(cut))
+        self.assertTrue(inst.equal(cut))  # most important
 
 
 class TensorFields_Test(TensorFields_Empty_Test):

tfields/core.py

@@ -1936,11 +1936,6 @@ class TensorFields(Tensors):
         for i, name in enumerate(names):
             self.fields[i].name = name
 
-    # def transform(self, coord_sys):
-    #     super(TensorFields, self).transform(coord_sys)
-    #     # for field in self.fields:
-    #     #     field.transform(coord_sys)
-
     def equal(self, other, **kwargs):
         """
         Test, whether the instance has the same content as other.
@@ -2118,15 +2113,15 @@ class Maps(sortedcontainers.SortedDict, AbstractObject):
         super().__init__(arg_tuple_list, **kwargs)
 
     @staticmethod
-    def to_map(mp, copy=False):
+    def to_map(mp, *fields, copy=False):
         if not copy:
-            if isinstance(mp, TensorFields):
+            if isinstance(mp, TensorFields) and not fields:
                 if not np.issubdtype(np.int32, np.integer):
                     mp = mp.astype(int)
             else:
                 copy = True
         if copy:  # not else, because in case of wrong mp type we initialize
-            mp = TensorFields(mp, dtype=int)
+            mp = TensorFields(mp, *fields, dtype=int)
         if not mp.rank == 1:
             raise ValueError(
                 "Incorrect map rank {mp.rank}".format(**locals())
@@ -2378,6 +2373,35 @@ class TensorMaps(TensorFields):
         else:
             return inst
 
+    def _cut_sympy(self, expression):
+        if len(self) == 0:
+            return self.copy()
+        mask = self.evalf(expression)  # coord_sys is handled by tmp_transform
+        mask.astype(bool)
+        inst = self[mask].copy()
+
+        # template
+        indices = np.arange(len(self))[mask]
+        # TODO: maybe np.empty instead of inst below. Reason why i copy is
+        # that the template is such marked for where it comes from.
+        # We have a trade-off with small memory consumpiton here.
+        template = tfields.TensorFields(inst, indices)
+        return inst, template
+
+    def _cut_template(self, template):
+        inst = super()._cut_template(template)
+
+        if template.fields:
+            # bulk was cut so we need to correct the map references.
+            index_lut = np.full(len(self), np.nan)
+            index_lut[template.fields[0]] = np.arange(len(template.fields[0]))
+        for mp_dim, mp in inst.maps.items():
+            mp = mp.cut(template.maps[mp_dim])
+            if template.fields:
+                mp = Maps.to_map(index_lut[mp], *mp.fields)
+            inst.maps[mp_dim] = mp
+        return inst
+
     def equal(self, other, **kwargs):
         """
         Test, whether the instance has the same content as other.
@@ -2398,8 +2422,8 @@ class TensorMaps(TensorFields):
 
             # >>> assert tm.equal(cp)
 
-            >>> cp.maps[0].fields[0] = -42
-            >>> assert tm.maps[0].fields[0] == 42
+            >>> cp.maps[1].fields[0] = -42
+            >>> assert tm.maps[1].fields[0] == 42
             >>> assert not tm.equal(cp)
 
         """

tfields/mesh3D.py

@@ -599,7 +599,7 @@ class Mesh3D(tfields.TensorMaps):
         key = 'mesh_tree'
         self._cache[key] = tree
 
-    def removeFaces(self, face_delete_mask):
+    def remove_faces(self, face_delete_mask):
         """
         Remove faces where face_delete_mask is True
         """
@@ -848,13 +848,13 @@ class Mesh3D(tfields.TensorMaps):
                     still overlaps with the cut.
                     These are at the intersection line between two cuts.
                     """
-                    faceIntersMask = np.full((inst.faces.shape[0]), False, dtype=bool)
+                    face_inters_mask = np.full((inst.faces.shape[0]), False, dtype=bool)
                     for i, face in enumerate(inst.faces):
                         vertices_rejected = [-mask[f] for f in face]
                         face_on_edge = any(vertices_rejected) and not all(vertices_rejected)
                         if face_on_edge:
-                            faceIntersMask[i] = True
-                    new_mesh.removeFaces(-faceIntersMask)
+                            face_inters_mask[i] = True
+                    new_mesh.remove_faces(-face_inters_mask)
 
                 for exprPart in expression_parts:
                     inst, _ = inst._cut_sympy(exprPart,