femagtools 1.8.3__py3-none-any.whl → 1.8.5__py3-none-any.whl

femagtools/dxfsl/geom.py

@@ -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
@@ -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/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

@@ -120,7 +120,15 @@ 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 = []
@@ -164,6 +172,7 @@ 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):
@@ -246,7 +255,6 @@ class Symmetry(object):
 
         check_rslt = self.build_results(areas)
         logger.debug("%s results available", len(check_rslt))
-        [logger.debug("Result: %s", rslt) for rslt in check_rslt]
 
         parts, start_delta = self.get_symmetry_parts(check_rslt)
         if parts < 2:
@@ -665,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]
@@ -712,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
@@ -720,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
@@ -740,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
@@ -788,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))
 

femagtools/fsl.py

@@ -556,7 +556,6 @@ class Builder:
         if 'fsl_rotor' in conv:
             self.fsl_rotor = True
             th_props = ['']
-            logger.debug(model['magnet'])
             if hasattr(model, 'magnet'):
                 if model['magnet'].get('thcond', 0):
                     th_props = [f'rotor_density = {model["magnet"]["density"]}',