femagtools 1.8.16__py3-none-any.whl → 1.8.18__py3-none-any.whl

femagtools/dxfsl/geom.py

@@ -35,7 +35,7 @@ from .functions import middle_angle, positive_angle
 from .functions import normalise_angle, is_same_angle
 from .functions import part_of_circle, gcd
 from .functions import point_on_arc, points_on_line, nodes_are_equal
-from .functions import area_size
+from .functions import area_size, get_angle_of_arc
 import io
 import time
 
@@ -401,11 +401,11 @@ class Geometry(object):
                    for n in self.g.nodes()}
         nx.relabel_nodes(self.g, mapping, copy=False)
 
-    def rotate_nodes(self, alpha, nodes):
+    def get_rotated_nodes(self, alpha, nodes):
         T = np.array(((np.cos(alpha), -np.sin(alpha)),
                       (np.sin(alpha), np.cos(alpha))))
-        rotnodes = np.dot(T, np.asarray(nodes).T).T.tolist()
-        return rotnodes
+        nodes = [T.dot(np.array((n[0], n[1]))).tolist() for n in nodes]
+        return nodes
 
     def rotate(self, alpha):
         """rotates all objects by angle alpha"""
@@ -1142,20 +1142,30 @@ class Geometry(object):
                              rtol=self.rtol,
                              atol=self.atol)
 
-    def get_corner_nodes(self, center, angle):
-        rtol = 1e-4
-        atol = 1e-4
-
+    def get_corner_nodes(self, center, angle, rtol=1e-4, atol=1e-4):
         center_added, corners = self.get_corner_list(center, angle, rtol, atol)
         if len(corners) < 2:
             return ()  # not enough corners
         return (corners[0].point(), corners[len(corners)-1].point())
 
-    def set_start_corners(self, center, angle):
-        self.start_corners = self.get_corner_nodes(center, angle)
+    def set_start_corners(self, center, angle, rtol=1e-4, atol=1e-4):
+        self.start_corners = self.get_corner_nodes(center, angle, rtol=rtol, atol=atol)
 
-    def set_end_corners(self, center, angle):
-        self.end_corners = self.get_corner_nodes(center, angle)
+    def set_end_corners(self, center, angle, rtol=1e-4, atol=1e-4):
+        self.end_corners = self.get_corner_nodes(center, angle, rtol=rtol, atol=atol)
+
+    def set_virtual_start_end_corners(self):
+        assert(not self.start_corners)
+        assert(not self.end_corners)
+
+        dist_list = [(distance(self.center, n), n) for n in self.nodes()]
+        dist_list.sort()
+        d1, c1 = dist_list[0]
+        d2, c2 = dist_list[-1]
+        corners = (c1, c2)
+        self.start_corners = corners
+        self.end_corners = corners
+        return
 
     def get_angle(self, alpha1, alpha2):
         if np.isclose(alpha1, alpha2, 0.001, 0.001):
@@ -1904,6 +1914,19 @@ class Geometry(object):
             self.area_list = []
         return nodes_deleted > 0
 
+    def delete_needless_elements(self, radius):
+        self.area_list = []
+        for e in self.elements():
+            if greater(distance(self.center, e.p1), radius):
+                self.remove_edge(e)
+            elif greater(distance(self.center, e.p2), radius):
+                self.remove_edge(e)
+            elif is_Arc(e):
+                p = e.center_of_connection()
+                if greater(distance(self.center, p), radius):
+                    self.remove_edge(e)
+        self.delete_all_appendices()
+
     def render_areagroups(self, renderer):
         if not self.areagroup_list:
             return
@@ -2036,11 +2059,47 @@ class Geometry(object):
                 return c
         return None
 
+    def check_hull_radius(self, center, radius, hull_points):
+        logger.debug("check_hull_radius")
+        min_r = radius
+        max_r = radius
+        for p in hull_points:
+            d = round(distance(center, p), 2)
+            min_r = min(min_r, d)
+            max_r = max(max_r, d)
+
+        if min_r > radius * 0.8:
+            # radius is ok, adjust hill line
+            return True, max_r > radius
+
+        return False, False
+
     def get_machine_part(self, mm):
         logger.debug("*** Begin of get_machine_part() ***")
 
         h_points = [h for h in convex_hull(self.virtual_nodes())]
-        center = self.get_center(h_points, mm)
+        center, radius = self.get_center_arcs(mm)
+        if center and radius:
+            center_left = round(center[0] - mm[0], 4)
+            center_right = round(mm[1] - center[0], 4)
+            center_down = round(center[1] - mm[2], 4)
+            center_up = round(mm[3] - center[1], 4)
+            min_r = min(center_left, center_right, center_up, center_down)
+            max_r = max(center_left, center_right, center_up, center_down)
+            is_full = min_r > max_r / 2
+
+            ok, adjust_hull = self.check_hull_radius(center, radius, h_points)
+            if is_full and ok:
+                self.set_center([round(center[0], 8), round(center[1], 8)])
+                self.area_list = []
+                machine = Machine(self,
+                                  radius=radius,
+                                  startangle=0.0,
+                                  endangle=0.0)
+                return machine
+
+        center = self.get_center(center, h_points, mm)
+
         logger.debug(" - Center is %s", center)
 
         min_radius = 99999
@@ -2259,9 +2318,14 @@ class Geometry(object):
     def is_same_center(self, center_lst, center, rtol, atol):
         for c in center_lst:
             if points_are_close(c['center'], center['center'], rtol, atol):
-                radius = center['radius'][0]
-                if not radius in c['radius']:
-                    c['radius'].append(radius)
+                new_radius, new_phi = center['radiuslist'][0]
+                c_radiuslist = [r for r, p in c['radiuslist']]
+                try:
+                    i = c_radiuslist.index(new_radius)
+                    c_radius, c_phi = c['radiuslist'][i]
+                    c['radiuslist'][i][1] = c_phi + new_phi
+                except:
+                    c['radiuslist'].append([new_radius, new_phi])
                 c['count'] = c['count'] + 1
                 return True
         return False
@@ -2283,7 +2347,6 @@ class Geometry(object):
             return None
         cy_list = [(c['center'][0], c) for c in c_list]
         cy_list.sort()
-        [logger.info("y=%s, c=%s", y, c) for y, c in cy_list]
         y, c = cy_list[0]
         return c
 
@@ -2302,14 +2365,23 @@ class Geometry(object):
                 return True
             return False
 
+        def get_best_radius(radiuslist):
+            radiuslist.sort(reverse=True)
+            r1, phi1 = radiuslist[0]
+            for r2, phi2 in radiuslist[1:]:
+                if phi2 > phi1:
+                    return r2
+                break
+            return r1
+
         circles = [e for e in self.elements() if is_Circle(e)]
         logger.debug(" -- %s Circles", len(circles))
 
         for e in circles:
             center = (round(e.center[0], 3), round(e.center[1], 3))
+            angle = e.get_angle_of_arc()
             entry = {'center': center,
-                     'radius': [round(e.radius, 1)],
-                     'phi': e.get_angle_of_arc(),
+                     'radiuslist':  [[round(e.radius, 1), angle]],
                      'dist': e.length(),
                      'inside': center_is_inside(center),
                      'count': 1}
@@ -2320,9 +2392,9 @@ class Geometry(object):
 
         for e in arcs:
             center = (round(e.center[0], 3), round(e.center[1], 3))
+            angle = e.get_angle_of_arc()
             entry = {'center': center,
-                     'radius': [round(e.radius, 1)],
-                     'phi': e.get_angle_of_arc(),
+                     'radiuslist': [[round(e.radius, 1), angle]],
                      'dist': e.length(),
                      'inside': center_is_inside(center),
                      'count': 1}
@@ -2330,7 +2402,7 @@ class Geometry(object):
                 center_list.append(entry)
 
         center = None
-        arc_list = [[c['count'], len(c['radius']), c['phi'], n, c]
+        arc_list = [[c['count'], len(c['radiuslist']), n, c]
                     for n, c in enumerate(center_list)]
         arc_list.sort(reverse=True)
 
@@ -2340,63 +2412,63 @@ class Geometry(object):
         [logger.debug("Arc %s", arc) for arc in arc_list]
         if not arc_list:
             logger.debug("end of get_center_arcs: no arcs")
-            return None
+            return None, 0
 
-        cnt, cr1, p, n, c1 = arc_list[0]
+        cnt, cr1, n, c1 = arc_list[0]
         logger.debug("First Entry: %s", c1)
         center = c1['center']
+        radius = get_best_radius(c1['radiuslist'])
         if len(arc_list) > 1:
-            cnt, cr2, p, n, c2 = arc_list[1]
+            cnt, cr2, n, c2 = arc_list[1]
             logger.debug("Second Entry: %s", c2)
             if not cr1 > cr2:
                 center = None
 
         if center:
-            logger.debug("end of get_center_arcs: -> %s", center)
-            return center
+            logger.debug("end of get_center_arcs: c=%s, r=%s", center, radius)
+            return center, radius
 
         c_entry = self.get_center_with_x(center_list, x_min)
         if c_entry:
             center = c_entry['center']
             if center[1] < y_min:
-                logger.debug("end of get_center_arcs: x -> %s", center)
-                return center
+                logger.debug("end of get_center_arcs (x): c=%s", center)
+                return center, 0
+
         c_entry = self.get_center_with_y(center_list, y_min)
         if c_entry:
             center = c_entry['center']
             if center[0] < x_min:
-                logger.debug("end of get_center_arcs: y -> %s", center)
-                return center
+                logger.debug("end of get_center_arcs (y): c=%s", center)
+                return center, 0
 
         logger.debug("end of get_center_arcs: no center found")
-        return None
+        return None, 0
 
     def get_center_dim(self, mm):
         return (round(mm[0], 4), round(mm[2], 4))
 
-    def get_center(self, points, mm):
-        logger.debug("Begin of get_center(%s points)", len(points))
-        if len(points) < 3:
+    def get_center(self, center_arcs, hull_points, mm):
+        logger.debug("Begin of get_center(%s hull-points)", len(hull_points))
+        if len(hull_points) < 3:
             return None
 
         center = None
         # Zuerst suchen wir anhand der Circle- und Arc-Segmente nach einem
         # möglichen Center-Punkt.
-        center_arcs = self.get_center_arcs(mm)
-
         if center_arcs:
             center = center_arcs
         else:
             # Wir finden keine Arc-Objekte, welche uns einen Hinweis auf den
             # Center geben können. Wir versuchen in der Verzweiflung mit
             # center_hull oder x(min) und y(min)
-            center_hull = self.get_center_hull(points)
+            center_hull = self.get_center_hull(_hull_points)
             if center_hull:
                 center = center_hull
             else:
                 center = self.get_center_dim(mm)
 
-        center_xaxis = self.get_center_xaxis(points)
+        center_xaxis = self.get_center_xaxis(hull_points)
         y = center_xaxis[1]
         if y is not None:
             if np.isclose(y, center[1], atol=0.3):
@@ -2612,6 +2684,7 @@ class Geometry(object):
             areas_inside = [a for a in self.area_list
                             if area.is_inside(a, self)]
             if not areas_inside:
+                area.areas_inside = {}
                 continue
 
             areas_notouch = {a.identifier(): a for a in areas_inside
@@ -3748,6 +3821,69 @@ class Geometry(object):
 
         logger.debug("end of search_unknown_subregions")
 
+    def possible_magnet_in_the_middle(self, midangle):
+        self.set_areas_inside_for_all_areas()
+        mags = []
+        for n, a in enumerate(self.list_of_areas()):
+            if a.areas_inside:
+                continue
+            if a.close_to_startangle or a.close_to_endangle:
+                continue
+            if np.isclose(a.min_dist, self.min_radius):
+                continue
+            if np.isclose(a.max_dist, self.max_radius):
+                continue
+
+            a_midangle = a.get_mid_angle(self.center)
+            if np.isclose(midangle, a_midangle, atol=1e-2, rtol=1e-2):
+                s = a.area_size()
+                mags.append([s, n, a, a_midangle])
+
+        if not mags:
+            logger.debug("possible_magnet_in_the_middle: No Areas for Magnets")
+            return None
+
+        mags.sort(reverse=True)
+        to_angle = np.pi / 2
+        for s, n, a, mid in mags:
+            angle = to_angle - mid
+            nodelist = a.list_of_nodes()
+            nodes = self.get_rotated_nodes(angle, nodelist)
+            p1 = self.center
+            p2 = point(self.center, self.max_radius + 10, mid)
+            line = Line(Element(start=p1, end=p2))
+            nodelist = a.get_intersect_points(line)
+            mid_nodes = self.get_rotated_nodes(angle, nodelist)
+            if self.is_possible_magnet(nodes, mid_nodes):
+                a.set_type(AREA.TYPE_MAGNET_AIRGAP)
+                a.phi = mid
+                a.mag_width = (a.max_dist - a.min_dist) * 0.9
+                return a
+
+        logger.debug("possible_magnet_in_the_middle: No Magnets")
+        return None
+
+    def is_possible_magnet(self, all_nodes, mid_nodes):
+        all_y = [n[1] for n in all_nodes]
+        all_y.sort()
+        mid_y = [n[1] for n in mid_nodes]
+        mid_y.sort()
+
+        logger.debug("is_possible_magnet: mid y min/max = %s/%s", mid_y[0], mid_y[-1])
+        logger.debug("is_possible_magnet: all y min/max = %s/%s", all_y[0], all_y[-1])
+
+        if all_y[0] > mid_y[-1]:
+            return False
+        return True
+
+    def force_area_as_magnet(self, area):
+        for a in self.list_of_areas():
+            if a.is_equal(area, 1e-2):
+                a.set_type(area.type)
+                a.phi = area.phi
+                a.mag_width = area.mag_width
+                return
+
     def magnets_in_the_middle(self, midangle):
         mag_areas = [a for a in self.list_of_areas()
                      if a.is_magnet()]
@@ -3768,16 +3904,20 @@ class Geometry(object):
         return False
 
     def looking_for_corners(self):
-        if self.is_inner:
-            logger.debug("looking_for_corners: inner")
-            start_cp = self.start_corners[-1]
-            end_cp = self.end_corners[-1]
-        else:
-            logger.debug("looking_for_corners: outer")
-            start_cp = self.start_corners[0]
-            end_cp = self.end_corners[0]
-        logger.debug("looking_for_corners: start=%s, end=%s",
-                     start_cp, end_cp)
+        try:
+            if self.is_inner:
+                logger.debug("looking_for_corners: inner")
+                start_cp = self.start_corners[-1]
+                end_cp = self.end_corners[-1]
+            else:
+                logger.debug("looking_for_corners: outer")
+                start_cp = self.start_corners[0]
+                end_cp = self.end_corners[0]
+            logger.debug("looking_for_corners: start=%s, end=%s",
+                         start_cp, end_cp)
+        except IndexError:
+            return
+
         for area in self.list_of_areas():
             area.mark_airgap_corners(start_cp, end_cp)
         return
@@ -4188,28 +4328,11 @@ class Geometry(object):
                         return True
         return False
 
-    def _line_inside_magnets(self, p1, p2):
-        for area in self.list_of_areas():
-            if area.is_magnet():
-                if area.is_point_inside(p1):
-                    if area.is_point_inside(p2):
-                        return True
-        return False
-
-    def _line_inside_air(self, p1, p2):
-        for area in self.list_of_areas():
-            if area.is_air():
-                if area.is_point_inside(p1):
-                    if area.is_point_inside(p2):
-                        return True
-        return False
-
     def _line_inside_not_iron(self, p1, p2):
         for area in self.list_of_areas():
             if area.is_shaft() or area.is_air() or area.is_magnet():
-                if area.is_point_inside(p1):
-                    if area.is_point_inside(p2):
-                        return True
+                if area.is_line_inside(p1, p2):
+                    return True
         return False
 
     def inside_area_list(self, p):
@@ -4301,6 +4424,73 @@ class Geometry(object):
         builder = AreaBuilder(geom=self)
         return builder.create_inner_corner_auxiliary_areas(startangle, endangle)
 
+    def analyse_airgap_line(self, inner):
+        if inner:  # TODO
+            return False
+
+        areas = self.list_of_areas()
+        builder = AreaBuilder(geom=self)
+        ag_nodes, ag_el = builder.get_outer_airgap_line()
+        if not ag_nodes:
+            logger.warning("Fatal: No nodes found")
+            return False
+
+        distlist = [distance(self.center, n) for n in ag_nodes]
+        min_dist = min(distlist)
+        max_dist = max(distlist)
+        logger.debug("Airgap min/max from center: %s/%s", min_dist, max_dist)
+        for a in areas:
+            logger.debug("%s: min/max from center: %s/%s", a.identifier(), a.min_dist, a.max_dist)
+            logger.debug("%s: min/max x: %s/%s,  y:  %s/%s",
+                         a.identifier(),
+                         a.min_x, a.max_x,
+                         a.min_y, a.max_y)
+            if less_equal(a.min_x, -min_dist) and greater_equal(a.max_x, min_dist) and \
+               less_equal(a.min_y, -min_dist) and greater_equal(a.max_y, min_dist):
+                logger.debug("%s: around center", a.identifier())
+                continue
+            if np.isclose(a.min_dist, min_dist, rtol=1e-3, atol=1e-2):
+                continue
+            if less_equal(a.max_dist, max_dist, rtol=1e-3, atol=1e-2):
+                return False
+
+        return builder.close_outer_winding_areas()
+
+    def adjust_outer_hull_for_symmetry(self):
+        logger.debug("adjust_outer_hull_for_symmetry()")
+        areas = self.list_of_areas()
+        builder = AreaBuilder(geom=self)
+        op_nodes, op_el = builder.get_outer_opposite_airgap_line()
+        if not op_nodes:
+            logger.warning("Fatal: No nodes found")
+            return False
+
+        radiuslist = {}
+        n1 = op_nodes[0]
+        d1 = distance(self.center, n1)
+        a1 = alpha_line(self.center, n1)
+        for n2 in op_nodes[1:]:
+            d2 = distance(self.center, n2)
+            a2 = alpha_line(self.center, n2)
+            if np.isclose(d1, d2, rtol=1e-3, atol=1e-2):
+                r = round((d1 + d2) / 2, 1)
+                alpha = get_angle_of_arc(a2, a1)
+                radius_alpha = radiuslist.get(r, 0.0) + alpha
+                radiuslist[r] = radius_alpha
+
+            n1 = n2
+            d1 = d2
+            a1 = a2
+
+        rlist = [(radiuslist[r], r) for r in radiuslist]
+        rlist.sort(reverse=True)
+        alpha, best_radius = rlist[0]
+        if np.isclose(best_radius, self.max_radius, rtol=1e-3, atol=1e-2):
+            return False
+        logger.debug("Best Outer Radius is %s", best_radius)
+        self.adjust_outer_hull(best_radius)
+        return True
+
     def close_outer_winding_areas(self):
         logger.debug("begin close_outer_winding_areas(%s areas)",
                      len(self.area_list))
@@ -4622,3 +4812,9 @@ class Geometry(object):
 
         with io.open(name, 'w', encoding='utf-8') as f:
             f.write('\n'.join(content))
+
+    def adjust_outer_hull(self, new_radius):
+        c = Circle(Element(center=self.center, radius=new_radius))
+        self.add_element(c, 1e-3, 1e-3)
+        self.delete_needless_elements(new_radius)
+        self.max_radius = new_radius

femagtools/dxfsl/machine.py

@@ -580,10 +580,8 @@ class Machine(object):
         return self.geom.create_auxiliary_lines(self.startangle, self.endangle)
 
     def set_alfa_and_corners(self):
-        self.geom.start_corners = self.geom.get_corner_nodes(self.center,
-                                                             self.startangle)
-        self.geom.end_corners = self.geom.get_corner_nodes(self.center,
-                                                           self.endangle)
+        self.geom.set_start_corners(self.center, self.startangle)
+        self.geom.set_end_corners(self.center, self.endangle)
         self.geom.alfa = alpha_angle(self.startangle, self.endangle)
 
         if self.mirror_geom is not None:
@@ -639,6 +637,22 @@ class Machine(object):
         if self.radius <= 0.0:
             return False
 
+        if is_outer:
+            self.geom.set_subregion_parameters(self.startangle, self.endangle)
+            if self.part > 1:
+                self.geom.set_start_corners(self.center, self.startangle, rtol=1e-3, atol=1e-2)
+                self.geom.set_end_corners(self.center, self.endangle, rtol=1e-3, atol=1e-2)
+            else:
+                self.geom.set_virtual_start_end_corners()
+
+            self.geom.looking_for_corners()
+            create_areas = self.geom.analyse_airgap_line(is_inner)
+            if self.geom.adjust_outer_hull_for_symmetry():
+                create_areas = True
+
+            if create_areas:
+                self.geom.create_list_of_areas(delete=True)
+
         symmetry = Symmetry(geom=self.geom,
                             startangle=self.startangle,
                             endangle=self.endangle)
@@ -1259,6 +1273,11 @@ class Machine(object):
     def has_magnets(self):
         return self.geom.has_magnets
 
+    def magnets_missing(self, EESM):
+        if EESM:
+            return False
+        return not self.has_magnets()
+
     def delete_tiny_elements(self, mindist):
         return self.geom.delete_tiny_elements(mindist)
 
@@ -1320,6 +1339,11 @@ class Machine(object):
                                 self.endangle)
         return self.geom.magnets_in_the_middle(midangle)
 
+    def looking_for_one_possible_magnet(self):
+        midangle = middle_angle(self.startangle,
+                                self.endangle)
+        return self.geom.possible_magnet_in_the_middle(midangle)
+
     def create_mirror_lines_outside_windings(self):
         logger.debug("create_mirror_lines_outside_windings")
 
@@ -1343,10 +1367,11 @@ class Machine(object):
         pts = self.geom.split_and_get_intersect_points(line, aktion=False)
         pts.sort()
 
+        arcs_created = False
         p_critical = self.geom.critical_touch_point(pts)
         if p_critical:
             d_critical = distance(self.center, p_critical)
-            logger.info("Critical Point: %s, len=%s", p_critical, d_critical)
+            logger.debug("Critical Point: %s, len=%s", p_critical, d_critical)
             sep_radius = self.get_iron_separator(radius_list)
             logger.debug("Iron Separator found: %s", sep_radius)
             if sep_radius > 0.0 and sep_radius < d_critical:
@@ -1357,8 +1382,15 @@ class Machine(object):
                     if r[1] < d_critical:
                         if self.create_arc(r[1]):
                             radius = r[1]
+                            arcs_created = True
                         break
 
+        if arcs_created:
+            self.geom.create_list_of_areas(delete=True)
+            self.geom.search_subregions(self.startangle,
+                                        self.endangle,
+                                        False)
+
         # install line
         line = Line(
             Element(start=self.center,
@@ -1366,11 +1398,9 @@ class Machine(object):
 
         pts = self.geom.split_and_get_intersect_points(line)
         pts.sort()
-
         if self.geom.create_lines_outside_windings(pts):
-            self.geom.area_list = []
             logger.debug("create subregions again")
-            self.geom.create_list_of_areas()
+            self.geom.create_list_of_areas(delete=True)
             self.geom.search_subregions(self.startangle,
                                         self.endangle,
                                         False)

femagtools/dxfsl/symmetry.py

@@ -48,6 +48,7 @@ class Symmetry(object):
         self.atol = atol
         self.full = False
         self.ag_radius = 0.0
+        self.height = geom.max_radius - geom.min_radius
         if np.isclose(self.startangle, self.endangle):
             self.alpha = 2.0*np.pi
             self.full = True
@@ -120,9 +121,6 @@ class Symmetry(object):
         areas.sort(reverse=True)
         return areas
 
-    def get_equal_areas(self, areas):
-        return
-
     def build_results(self, areas):
         logger.debug("begin of build_results with %s areas", len(areas))
         [logger.debug("#%s: alpha=%s, min=%s, max=%s",
@@ -286,13 +284,22 @@ class Symmetry(object):
         logger.debug("Geometry: Alpha=%s,  Center=%s", self.alpha, self.geom.center)
         mid_angle, a = area_list[0]
         result['height'] = a.height
+        result['min_dist'] = a.min_dist
+        result['max_dist'] = a.max_dist
         result['alpha'] = a.get_alpha(self.geom.center)
         if self.geom.is_inner:
             result['airgap'] = np.isclose(a.max_dist, self.ag_radius)
         else:
             result['airgap'] = np.isclose(a.min_dist, self.ag_radius)
+            upper_quarter = self.geom.min_radius + self.height * 0.75
+            upper_half = self.geom.min_radius + self.height * 0.5
+            if a.max_dist > upper_quarter:
+                if a.min_dist > upper_half:
+                    result['upper_quarter'] = True
         if len(area_list) == 1:  # one area
-            return self.check_one_area(mid_angle, a, result, rtol=rtol, atol=atol)
+            rslt = self.check_one_area(mid_angle, a, result, rtol=rtol, atol=atol)
+            logger.debug("end of check_delta")
+            return rslt
 
         self.delta_check_count += 1
         area_list.sort()
@@ -353,6 +360,7 @@ class Symmetry(object):
             logger.debug("end of check_delta: BAD DELTA %s, (expected %s)",
                          delta_angle, geom_alpha)
             result['slices'] = 0
+            logger.debug("end of check_delta: very bad")
             return result  # very bad
 
         deltas = self.create_deltas(delta_list, rtol=rtol, atol=atol)
@@ -927,13 +935,20 @@ class Symmetry(object):
                     logger.debug("Symmetry-Destroyer destroyed")
                     slices = None
 
+            if rslt.get('upper_quarter', False):
+                if size < max_size / 20:
+                    slices = None
+
+            if slices == 1:
+                if rslt.get('upper_quarter', False):
+                    slices = None
+
             if slices == 1:
                 # symmetry killer
                 if areas < max(2, max_areas / 6):
                     if size < max_size * 0.05:
                         slices = None  # ignore tiny areas
 
-
             parts_possible = self.calc_parts(parts_possible, slices)
 
         if unsure_sym: