femagtools 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

femagtools/dxfsl/geom.py

@@ -1986,7 +1986,7 @@ class Geometry(object):
                                startangle=0.0,
                                endangle=np.pi/2)
 
-        elif np.isclose(width, height*2, self.rtol, self.atol):
+        elif np.isclose(width, height*2, rtol=1e-2, atol=1e-2):
             radius = width/2
             self.set_center([mm[1]-height, mm[2]])
             logger.info("check for half machine")
@@ -2005,7 +2005,7 @@ class Geometry(object):
                                startangle=np.pi,
                                endangle=0.0)
 
-        elif np.isclose(width*2, height, self.rtol, self.atol):
+        elif np.isclose(width*2, height, rtol=1e-2, atol=1e-2):
             radius = width
             logger.info("check for half machine")
             self.set_center([mm[1], mm[3]-width])
@@ -2256,45 +2256,120 @@ class Geometry(object):
             return center[0]
         return None
 
-    def get_center_arcs(self):
+    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)
+                c['count'] = c['count'] + 1
+                return True
+        return False
+
+    def get_center_with_x(self, center_lst, x):
+        c_list = [c for c in center_lst
+                  if np.isclose(c['center'][0], x, rtol=self.rtol, atol=self.atol)]
+        if not c_list:
+            return None
+        cy_list = [(c['center'][1], c) for c in c_list]
+        cy_list.sort()
+        y, c = cy_list[0]
+        return c
+
+    def get_center_with_y(self, center_lst, y):
+        c_list = [c for c in center_lst
+                  if np.isclose(c['center'][1], y, rtol=self.rtol, atol=self.atol)]
+        if not c_list:
+            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
+
+    def get_center_arcs(self, mm):
         logger.debug("begin of get_center_arcs")
         center_list = []
+        x_min, x_max, y_min, y_max = mm
+
+        def center_is_inside(c):
+            tol = 0.1
+            x, y = c
+            if x-tol > x_min and \
+               x+tol < x_max and \
+               y-tol > y_min and \
+               y+tol < y_max:
+                return True
+            return False
+
         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))
-            radius = round(e.radius, 1)
-            center_list.append(([1], center, [radius]))
+            entry = {'center': center,
+                     'radius': [round(e.radius, 1)],
+                     'phi': e.get_angle_of_arc(),
+                     'dist': e.length(),
+                     'inside': center_is_inside(center),
+                     'count': 1}
+            center_list.append(entry)
 
         arcs = [e for e in self.elements() if is_Arc(e)]
         logger.debug(" -- %s Arcs", len(arcs))
 
         for e in arcs:
             center = (round(e.center[0], 3), round(e.center[1], 3))
-            radius = round(e.radius, 1)
-            c = self.get_same_center(center_list, center, self.rtol, self.atol)
-            if c is None:
-                center_list.append(([1], center, [radius]))
-            else:
-                c[0][0] += 1
-                if radius not in c[2]:
-                    c[2].append(radius)
+            entry = {'center': center,
+                     'radius': [round(e.radius, 1)],
+                     'phi': e.get_angle_of_arc(),
+                     'dist': e.length(),
+                     'inside': center_is_inside(center),
+                     'count': 1}
+            if not self.is_same_center(center_list, entry, self.rtol, self.atol):
+                center_list.append(entry)
 
         center = None
-        arc_list = [[len(c[2]), c[0][0], c[1]] for c in center_list]
+        arc_list = [[c['count'], len(c['radius']), c['phi'], n, c]
+                    for n, c in enumerate(center_list)]
         arc_list.sort(reverse=True)
 
-        if arc_list:
-            c1 = arc_list[0]
-            center = c1[2]
-            if len(arc_list) > 1:
-                c2 = arc_list[1]
-                if not c1[0] > c2[0]:
-                    center = None
+        logger.debug("x min/max = %s/%s", x_min, x_max)
+        logger.debug("y min/max = %s/%s", y_min, y_max)
 
-        logger.debug("end of get_center_arcs: -> %s", center)
-        return center
+        [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
+
+        cnt, cr1, p, n, c1 = arc_list[0]
+        logger.debug("First Entry: %s", c1)
+        center = c1['center']
+        if len(arc_list) > 1:
+            cnt, cr2, p, 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
+
+        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
+        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: no center found")
+        return None
 
     def get_center_dim(self, mm):
         return (round(mm[0], 4), round(mm[2], 4))
@@ -2305,7 +2380,9 @@ class Geometry(object):
             return None
 
         center = None
-        center_arcs = self.get_center_arcs()
+        # 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
@@ -2409,31 +2486,31 @@ class Geometry(object):
         logger.debug("end check_airgap: return %s", len(area_id_list) > 1)
         return len(area_id_list) > 1  # bad
 
-    def is_border_line(self, center, startangle, endangle, e, atol):
+    def is_border_line(self, center, startangle, endangle, e, rtol=1e-3, atol=1e-3):
         if isinstance(e, Line):
             if np.isclose(startangle, endangle):
                 return False  # full
 
             if points_are_close(center, e.p1):
                 angle_p2 = alpha_line(center, e.p2)
-                if np.isclose(startangle, angle_p2, 1e-3, atol):
+                if np.isclose(startangle, angle_p2, rtol=rtol, atol=atol):
                     return True
-                return np.isclose(endangle, angle_p2, 1e-3, atol)
+                return np.isclose(endangle, angle_p2, rtol=rtol, atol=atol)
 
             if points_are_close(center, e.p2):
                 angle_p1 = alpha_line(center, e.p1)
-                if np.isclose(startangle, angle_p1, 1e-3, atol):
+                if np.isclose(startangle, angle_p1, rtol=rtol, atol=atol):
                     return True
-                return np.isclose(endangle, angle_p1, 1e-3, atol)
+                return np.isclose(endangle, angle_p1, rtol=rtol, atol=atol)
 
             angle_p1 = alpha_line(center, e.p1)
-            if np.isclose(startangle, angle_p1, 1e-3, atol):
+            if np.isclose(startangle, angle_p1, rtol=rtol, atol=atol):
                 angle_p2 = alpha_line(center, e.p2)
-                return np.isclose(startangle, angle_p2, 1e-3, atol)
+                return np.isclose(startangle, angle_p2, rtol=rtol, atol=atol)
 
-            if np.isclose(endangle, angle_p1, 1e-3, atol):
+            if np.isclose(endangle, angle_p1, rtol=rtol, atol=atol):
                 angle_p2 = alpha_line(center, e.p2)
-                return np.isclose(endangle, angle_p2, 1e-3, atol)
+                return np.isclose(endangle, angle_p2, rtol=rtol, atol=atol)
         return False
 
     def get_gaplist(self, center):
@@ -2457,7 +2534,7 @@ class Geometry(object):
         """
         gaplist = []
         for e in self.elements(Shape):
-            if not self.is_border_line(center, startangle, endangle, e, atol):
+            if not self.is_border_line(center, startangle, endangle, e, atol=atol):
                 gaplist += [e.minmax_from_center(center)]
             else:
                 min_r, max_r = e.minmax_from_center(center)
@@ -3259,7 +3336,7 @@ class Geometry(object):
             max_size, max_w = windings_surface[0]
             for sz, w in windings_surface[1:]:
                 logger.debug("winding size = %s", sz)
-                if sz / max_size < 0.80:
+                if sz / max_size < 0.70:
                     w.set_type(AREA.TYPE_AIR)
                     if sz / max_size < 0.2:
                         windings_found -= 1

femagtools/dxfsl/journal.py

@@ -18,7 +18,7 @@ logger = logging.getLogger('femagtools.journal')
 journal = None
 
 #############################
-#           concat          #
+#          journal          #
 #############################
 
 

femagtools/dxfsl/machine.py

@@ -135,6 +135,16 @@ class Machine(object):
         self.geom.is_outer = True
         self.geom.is_inner = False
 
+    def set_attributes(self,
+                       kind="",
+                       inner=False,
+                       outer=False):
+        self.set_kind(kind)
+        if inner:
+            self.set_inner()
+        if outer:
+            self.set_outer()
+
     def clear_cut_lines(self):
         self.geom.clear_cut_lines()
         if self.mirror_geom is not None:
@@ -635,9 +645,13 @@ class Machine(object):
         parts = symmetry.find_symmetry()  # temp solution
         logger.debug(">>> Symmetry parts = %s <<<", parts)
 
-        if parts > 1:
-            found = True
-        else:
+        if parts == 1:
+            # no slices, but ok
+            return False
+
+        found = (parts > 1)
+
+        if not found:
             found = self.geom.find_symmetry(self.radius,
                                             self.startangle,
                                             self.endangle,
@@ -833,11 +847,11 @@ class Machine(object):
             if dist_start > dist_end:
                 machine.mirror_all_areas(self.startangle)
                 machine.rotate_to(angle)
-                machine.geom.create_list_of_areas(delete=True)
                 machine.startangle -= angle
             else:
                 machine.mirror_all_areas(self.endangle)
                 machine.endangle += angle
+            machine.geom.create_list_of_areas(delete=True)
             machine.set_alfa_and_corners()
             machine.part = machine.part_of_circle()
             machine.geom.set_subregion_parameters(self.startangle,
@@ -907,23 +921,25 @@ class Machine(object):
                                             first_thirdangle,
                                             second_thirdangle)
         machine_mirror_1.clear_cut_lines()
-
         machine_mirror_1.repair_hull()
         machine_mirror_1.set_alfa_and_corners()
+        if machine_mirror_1.geom.number_of_edges() < 2:  # very bad
+            logger.debug("end get_third_symmetry_mirror: no remaining elements")
+            return None
         if not machine_mirror_1.check_symmetry_graph(0.001, 0.05):
             logger.debug("end get_third_symmetry_mirror: no mirror first third")
             return None
 
         if plt:
             plt.render_elements(machine_mirror_1.geom, Shape,
-                                title="Part",
+                                title="Part 1",
                                 show=True,
                                 with_corners=False,
                                 with_nodes=False,
                                 neighbors=True)
 
             plt.render_elements(machine_mirror_1.mirror_geom, Shape,
-                                title="Counterpart",
+                                title="Counterpart 1",
                                 show=True,
                                 with_corners=False,
                                 with_nodes=False,
@@ -935,10 +951,28 @@ class Machine(object):
         machine_mirror_2.clear_cut_lines()
         machine_mirror_2.repair_hull()
         machine_mirror_2.set_alfa_and_corners()
+        if machine_mirror_2.geom.number_of_edges() < 2:  # very bad
+            logger.debug("end get_third_symmetry_mirror: no remaining elements")
+            return None
         if not machine_mirror_2.check_symmetry_graph(0.001, 0.05):
             logger.debug("end get_third_symmetry_mirror: no mirror second third")
             return None
 
+        if plt:
+            plt.render_elements(machine_mirror_2.geom, Shape,
+                                title="Part 2",
+                                show=True,
+                                with_corners=False,
+                                with_nodes=False,
+                                neighbors=True)
+
+            plt.render_elements(machine_mirror_2.mirror_geom, Shape,
+                                title="Counterpart 2",
+                                show=True,
+                                with_corners=False,
+                                with_nodes=False,
+                                neighbors=True)
+
         machine_mirror_1.previous_machine = self
         logger.debug("end get_third_symmetry_mirror: ok")
         return machine_mirror_1
@@ -992,6 +1026,9 @@ class Machine(object):
                                 with_nodes=False,
                                 neighbors=True)
 
+        if machine_mirror.geom.number_of_edges() < 2:  # very bad
+            logger.debug("end get_symmetry_mirror: no remaining elements")
+            return None
         if machine_mirror.check_symmetry_graph(0.001, 0.05):
             machine_mirror.previous_machine = self
             machine_mirror.rotate_to(0.0)

femagtools/dxfsl/shape.py

@@ -467,6 +467,10 @@ class Circle(Shape):
         r0 = np.linalg.norm(self.center)
         return max(abs(r-r0-self.radius), abs(r-r0+self.radius))
 
+    def length(self):
+        """returns length of this circle"""
+        return self.radius*2*np.pi
+
     def overlapping_shape(self, e, rtol=1e-03, atol=1e-03):
         if not (isinstance(e, Arc) or isinstance(e, Circle)):
             # end overlapping_shape: Circle (not Arc or Circle)

femagtools/dxfsl/symmetry.py

@@ -102,6 +102,7 @@ class Symmetry(object):
                                           a.get_mid_angle(self.geom.center)))
 
     def area_list_entry(self, a):
+        a.set_symmetry_parameter(self.geom.center)
         return (round(a.get_alpha(self.geom.center), 3),
                 round(a.min_dist, 1),
                 round(a.height, 1),
@@ -119,24 +120,47 @@ 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",
+                      a.get_id(), alpha, a.min_angle, a.max_angle) for
+         alpha, dist, h, mid, a in areas]
+
         a0_alpha, a0_min_dist, a0_height, a0_mid_angle, a0 = areas[0]
         equal_areas = [(a0_mid_angle, a0)]
         check_rslt = []
         for a1_alpha, a1_min_dist, a1_height, a1_mid_angle, a1 in areas[1:]:
-            if self.equal_area(a0_min_dist, a0_height, a0_alpha,
-                               a1_min_dist, a1_height, a1_alpha,
-                               rtol=0.001, atol=0.05):
+            if (self.equal_area(a0_min_dist, a0_height, a0_alpha,
+                                a1_min_dist, a1_height, a1_alpha,
+                                rtol=0.001, atol=0.05)):
                 a0_min_dist = (a0_min_dist + a1_min_dist) / 2
                 a0_height = (a0_height + a1_height) / 2
                 a0_alpha = (a0_alpha + a1_alpha) / 2
                 equal_areas.append((a1_mid_angle, a1))
             else:
-                rslt = self.check_delta(equal_areas)
-                areasize = a0.area_size()
-                rslt['area'] = a0
-                rslt['areasize'] = areasize
-                check_rslt.append((areasize, rslt))
+                # alpha Wechsel
+                id_list = []
+                for i in range(len(equal_areas)):
+                    mid_angle0, area0 = equal_areas[i]
+                    if area0.get_id() in id_list:
+                        continue
+                    equal_areas_check = [(mid_angle0, area0)]
+                    for mid_angle1, area1 in equal_areas[i+1:]:
+                        if area1.get_id() in id_list:
+                            continue
+                        if area0.is_symmetry_equal(area1):
+                            equal_areas_check.append((mid_angle1, area1))
+                            id_list.append(area1.get_id())
+
+                    rslt = self.check_delta(equal_areas_check)
+                    areasize = a0.area_size()
+                    rslt['area'] = a0
+                    rslt['areasize'] = areasize
+                    check_rslt.append((areasize, rslt))
+
                 equal_areas = [(a1_mid_angle, a1)]
                 a0_min_dist = a1_min_dist
                 a0_height = a1_height
@@ -148,12 +172,14 @@ class Symmetry(object):
         rslt['area'] = a0
         rslt['areasize'] = areasize
         check_rslt.append((areasize, rslt))
+        logger.debug("end of build_results")
         return check_rslt
 
     def get_winding_symmetry(self, inside=False):
         if inside:
             areas = [self.area_list_entry(a) for a in self.geom.list_of_areas()
                      if not a.close_to_ag]
+            areas.sort(reverse=True)
         else:
             areas = self.build_area_list((AREA.TYPE_WINDINGS,))
 
@@ -228,6 +254,7 @@ class Symmetry(object):
             return 0
 
         check_rslt = self.build_results(areas)
+        logger.debug("%s results available", len(check_rslt))
 
         parts, start_delta = self.get_symmetry_parts(check_rslt)
         if parts < 2:
@@ -248,6 +275,7 @@ class Symmetry(object):
         result = {'areas': len(area_list),
                   'startdelta': 0.0,
                   'slices': None}
+        result['area_id_list'] = [a.get_id() for m, a in area_list]
         if not area_list:
             logger.debug("end of check_delta: no areas")
             return result
@@ -645,6 +673,9 @@ class Symmetry(object):
             m1 = m2
             d1 = d2
 
+        if not mid_list:
+            return None
+
         logger.debug("New Mids: %s", mid_list)
         delta = positive_angle(mid_list[0] * 2)
         delta_list = [delta]
@@ -692,6 +723,41 @@ class Symmetry(object):
         logger.debug("end check_first_last_difference => %s", n1 + 1)
         return n1 + 1
 
+    def concatenate_results(self, check_rslt):
+        if len(check_rslt) < 2:
+            return check_rslt
+        #   ----------
+        def get_slices(rslt):
+            if rslt['slices'] is None:
+                return 0
+            if rslt.get('startdelta', 0.0) != 0.0:
+                return 0
+            if rslt.get('halfslice', None) is not None:
+                return 0
+            return rslt['slices']
+        #   ------
+        new_rslt = []
+        size1, n1, rslt1 = check_rslt[0]
+        slices1 = get_slices(rslt1)
+        for size2, n2, rslt2 in check_rslt[1:]:
+            slices2 = get_slices(rslt2)
+            if slices1 > 0 and \
+               slices1 == slices2 and \
+               np.isclose(size1, size2, rtol=1e-01, atol=1e-01) and \
+               (rslt1.get('delta_corr', 0.0) == 0.0 or \
+                rslt2.get('delta_corr', 0.0) == 0.0):
+                # concatenate
+                rslt1['slices'] = None
+                rslt2['delta_corr'] = 0.0
+                rslt2['areas'] = rslt2['areas'] + rslt1['areas']
+                logger.debug("concatenate results(size %s)", size1)
+            else:
+                new_rslt.append((size1, n1, rslt1))
+            slices1, size1, n1, rslt1 = (slices2, size2, n2, rslt2)
+
+        new_rslt.append((size1, n1, rslt1))
+        return new_rslt
+
     def get_symmetry_parts(self, check_rslt):
         max_size = 0
         max_areas = 0
@@ -700,10 +766,11 @@ class Symmetry(object):
         self.delta_angle_corr = None
         unsure_sym = False
 
-        check_rslt = [(size, n, rslt) for n, (size, rslt) in enumerate(check_rslt)]
+        check_rslt = [(size, n, rslt) for n, (size, rslt) in enumerate(check_rslt)
+                      if rslt['slices'] is not None]
         check_rslt.sort(reverse=True)
-        for size, n, rslt in check_rslt:
-            logger.debug("Result: %s, %s", size, rslt)
+        check_rslt = self.concatenate_results(check_rslt)
+        [logger.debug("Result #%s: %s, %s", n, size, rslt) for size, n, rslt in check_rslt]
 
         rtol = 1e-3
         atol = 1e-2
@@ -720,40 +787,46 @@ class Symmetry(object):
         for size, n, rslt in check_rslt:
             areas = rslt['areas']
             slices = rslt['slices']
+            if slices is None:
+                continue
+
             size = rslt['areasize']
             angle_corr = rslt.get('delta_corr', 0.0)
 
             if rslt.get('halfslice', 0) == 1:
                 halfslice.append(rslt)
 
-            if slices is not None:
-                if slices > 0:
-                    max_size = max(max_size, size)
-                    max_areas = max(max_areas, areas)
-                    max_slices = max(max_slices, slices)
-                    missing_middles += rslt.get('missing_middles', [])
-                    area = rslt['area']
-                    if not (np.isclose(area.min_dist,
-                                       self.geom.min_radius,
-                                       rtol=1e-4, atol=1e-3) and \
-                            np.isclose(area.max_dist,
-                                       self.geom.max_radius,
-                                       rtol=1e-4, atol=1e-3)):
-                        if rslt.get('delta_corr', 0.0) == 0.0:
-                            without_angle_corr += areas * size
-                        else:
-                            with_angle_corr += areas * size
+            if slices > 0:
+                max_size = max(max_size, size)
+                max_areas = max(max_areas, areas)
+                max_slices = max(max_slices, slices)
+                missing_middles += rslt.get('missing_middles', [])
+                area = rslt['area']
+                if not (np.isclose(area.min_dist,
+                                   self.geom.min_radius,
+                                   rtol=1e-4, atol=1e-3) and \
+                        np.isclose(area.max_dist,
+                                   self.geom.max_radius,
+                                   rtol=1e-4, atol=1e-3)):
+                    if rslt.get('delta_corr', 0.0) == 0.0:
+                        without_angle_corr += areas * size
                     else:
-                        maybe_angle_korr += areas * size
+                        with_angle_corr += areas * size
+                else:
+                    maybe_angle_korr += areas * size
+
         logger.debug("max size: %s,  max areas: %s", max_size, max_areas)
+        logger.debug("Angle-Corrections: %s Yes,  %s No, %s Maybe",
+                     with_angle_corr,
+                     without_angle_corr,
+                     maybe_angle_korr)
 
-        logger.debug("Angle-Corrections: %s Yes,  %s No",
-                     with_angle_corr, without_angle_corr)
         if np.isclose(with_angle_corr, without_angle_corr):
             with_angle_corr = (maybe_angle_korr > 0)
         else:
             with_angle_corr = (with_angle_corr > without_angle_corr)
 
+        #   -------------------------
         def get_halfslice_counterpart(rslt):
             if rslt.get('halfslice', 0) != 2:
                 return None
@@ -768,7 +841,7 @@ class Symmetry(object):
                    np.isclose(alpha1, alpha2, rtol=rtol, atol=atol):
                     return half
             return None
-
+        #   -----------
         if halfslice:
             logger.debug("%s halfslice [1] found", len(halfslice))