femagtools 1.8.17__py3-none-any.whl → 1.8.19__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, 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)
 
-    def set_end_corners(self, center, angle):
-        self.end_corners = self.get_corner_nodes(center, angle)
+        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):
@@ -1172,7 +1182,7 @@ class Geometry(object):
             nx.set_edge_attributes(self.g, False, 1)
             nx.set_edge_attributes(self.g, False, 2)
 
-    def create_list_of_areas(self, main=False, delete=False):
+    def create_list_of_areas(self, main=False, delete=False, nolog=True):
         """ return list of areas for each node and their neighbors
         """
         if delete:  # clear list of areas
@@ -1183,7 +1193,7 @@ class Geometry(object):
             # list already available
             return
 
-        areabuilder = AreaBuilder(geom=self)
+        areabuilder = AreaBuilder(geom=self, nolog=nolog)
         areabuilder.create_list_of_areas(main=main)
         self.area_list = areabuilder.area_list
         logger.debug("area list created")
@@ -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):
@@ -3265,6 +3337,31 @@ class Geometry(object):
         return [a for a in self.list_of_areas()
                 if a.is_type(type)]
 
+    def is_tooth(self, a, windings, wdg_min_dist, wdg_max_dist):
+        if a.around_windings(windings, self):
+            if a.close_to_ag:
+                return True
+            if self.is_inner:
+                if greater(a.min_dist, wdg_min_dist, atol=1e-1):
+                    return True
+            else:
+                if less(a.max_dist, wdg_max_dist, atol=1e-1):
+                    return True
+        return False
+
+    def between_airgap_and_winding(self, a,
+                                   wdg_min_angle,
+                                   wdg_max_angle,
+                                   wdg_min_dist,
+                                   wdg_max_dist):
+        if greater_equal(a.min_angle, wdg_min_angle) and \
+           less_equal(a.max_angle, wdg_max_angle):
+            if self.is_inner:
+                return less_equal(wdg_max_dist, a.min_dist)
+            else:
+                return less_equal(a.max_dist, wdg_min_dist)
+        return False
+
     def collect_windings(self):
         logger.debug("begin of collect_windings")
         good_windings = self.get_windings(AREA.TYPE_WINDINGS)
@@ -3337,7 +3434,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.70:
+                if sz / max_size < 0.60:
                     w.set_type(AREA.TYPE_AIR)
                     if sz / max_size < 0.2:
                         windings_found -= 1
@@ -3387,7 +3484,7 @@ class Geometry(object):
         air_areas = [a for a in self.list_of_areas()
                      if a.is_type(AREA.TYPE_AIR_OR_IRON)]
         for a in air_areas:
-            if a.around_windings(windings, self):
+            if a.around_windings(windings, self) and less(a.min_dist, wdg_max_dist - 0.5):
                 logger.debug("Area %s", a.identifier())
                 logger.debug(" - air-angle min/max = %s/%s",
                              a.min_air_angle,
@@ -3409,7 +3506,6 @@ class Geometry(object):
                            a.close_to_ag):
                             a.set_type(AREA.TYPE_AIR)  # air
                             continue
-
                         a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
                         continue
 
@@ -3438,14 +3534,28 @@ class Geometry(object):
                     a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
             else:
                 logger.debug("#5 not around windings")
-                a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
+                if self.between_airgap_and_winding(a,
+                                                   wdg_min_angle, wdg_max_angle,
+                                                   wdg_min_dist, wdg_max_dist):
+                    a.set_type(AREA.TYPE_AIR)  # air
+                else:
+                    if self.is_inner:
+                        if greater(a.min_dist, wdg_min_dist, atol=1e-1):
+                            a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
+                        else:
+                            a.set_type(AREA.TYPE_YOKE)  # iron shaft (Joch)
+                    else:
+                        if less(a.max_dist, wdg_max_dist, atol=1e-1):
+                            a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
+                        else:
+                            a.set_type(AREA.TYPE_YOKE)  # iron shaft (Joch)
 
         # yoke or shaft ?
         iron_areas = [a for a in self.list_of_areas()
                       if a.is_type(AREA.TYPE_YOKE)]
         for a in iron_areas:
             if a.around_windings(windings, self):
-                if less(a.min_dist, wdg_max_dist):
+                if less(a.min_dist, wdg_max_dist - 0.5):
                     if less_equal(a.max_dist, wdg_max_dist):
                         a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
                     else:
@@ -3765,16 +3875,44 @@ class Geometry(object):
             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])
+                mags.append([s, n, a, a_midangle])
 
         if not mags:
-            return False
+            logger.debug("possible_magnet_in_the_middle: No Areas for Magnets")
+            return None
+
         mags.sort(reverse=True)
-        s, n, a = mags[0]
-        a.set_type(AREA.TYPE_MAGNET_AIRGAP)
-        a.phi = midangle
-        a.mag_width = (a.max_dist - a.min_dist) * 0.9
-        return a
+        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():
@@ -3804,20 +3942,33 @@ 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
 
+    def get_areas_of_type(self, types=()):
+        return [area for area in self.list_of_areas()
+                if area.type in types]
+
+    def get_areas_of_irons(self):
+        return self.get_areas_of_type((AREA.TYPE_IRON,
+                                       AREA.TYPE_YOKE,
+                                       AREA.TYPE_TOOTH,))
+
     def num_areas_of_type(self, types=()):
         return len([area for area in self.list_of_areas()
                     if area.type in types])
@@ -4164,6 +4315,16 @@ class Geometry(object):
         for e in self.elements():
             e.adjust_points()
 
+    def split_with_point(self, p):
+        for e in self.elements(Shape):
+            elements = e.split([p])
+            if elements:
+                self.remove_edge(e)
+                for e in elements:
+                    self.add_element(e, rtol=self.rtol, atol=self.atol)
+                return True
+        return False
+
     def split_and_get_intersect_points(self, el, aktion=True, include_end=True):
         logger.debug("begin of split_and_get_intersect_points")
         rtol = 1e-03
@@ -4320,6 +4481,41 @@ class Geometry(object):
         builder = AreaBuilder(geom=self)
         return builder.create_inner_corner_auxiliary_areas(startangle, endangle)
 
+    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))
@@ -4641,3 +4837,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