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

femagtools/dxfsl/machine.py

@@ -247,16 +247,21 @@ class Machine(object):
                            startangle=self.startangle,
                            endangle=self.endangle)
 
-    def full_copy(self, concatenate_matching_el=False):
+    def clone(self):
         clone = self.geom.copy_shape(self.radius,
                                      0.0, 2*np.pi,
-                                     0.0, self.radius+9999,
-                                     concatenate_matching_el=concatenate_matching_el)
+                                     0.0,
+                                     self.radius+9999,
+                                     concatenate=False,
+                                     connect=False)
         clone.kind = self.geom.kind
         clone.sym_part = self.geom.sym_part
         clone.sym_counterpart = self.geom.sym_counterpart
         clone.alfa = self.geom.alfa
-        self.geom = clone
+        return Machine(clone,
+                       radius = self.radius,
+                       startangle=self.startangle,
+                       endangle=self.endangle)
 
     def copy_mirror(self, startangle, midangle, endangle):
         logger.debug("begin of copy_mirror")
@@ -532,7 +537,7 @@ class Machine(object):
         logger.debug('begin repair_hull_geom (%s, %s)', startangle, endangle)
 
         rtol = 1e-3
-        atol = 1e-4
+        atol = 1e-3
         c_corner = Corner(self.center, self.center)
         start_c_added, start_corners = geom.get_corner_list(self.center, startangle,
                                                             rtol=rtol, atol=atol)
@@ -590,8 +595,34 @@ class Machine(object):
         return w
 
     def slot_area(self):
-        from .area import TYPE_WINDINGS
-        return self.geom.area_size_of_type(TYPE_WINDINGS)
+        return self.geom.area_size_of_type(AREA.TYPE_WINDINGS)
+
+    def get_winding_symmetry(self, inside=False):
+        logger.debug("begin of get_winding_symmetry")
+        symmetry = Symmetry(geom=self.geom,
+                            startangle=self.startangle,
+                            endangle=self.endangle)
+        parts = symmetry.get_winding_symmetry(inside=inside)
+        logger.debug("end of get_winding_symmetry (parts=%s)", parts)
+        return parts
+
+    def get_magnet_symmetry(self):
+        logger.debug("begin of get_magnet_symmetry")
+        symmetry = Symmetry(geom=self.geom,
+                            startangle=self.startangle,
+                            endangle=self.endangle)
+        parts = symmetry.get_magnet_symmetry()
+        logger.debug("end of get_magnet_symmetry (parts=%s)", parts)
+        return parts
+
+    def get_symmetry(self):
+        logger.debug("begin of get_symmetry")
+        symmetry = Symmetry(geom=self.geom,
+                            startangle=self.startangle,
+                            endangle=self.endangle)
+        parts = symmetry.find_symmetry()
+        logger.debug("end of get_symmetry (parts=%s)", parts)
+        return parts
 
     def find_symmetry(self, sym_tolerance, is_inner, is_outer, plt):
         logger.debug("begin of find_symmetry")
@@ -761,6 +792,97 @@ class Machine(object):
                              self.geom.symmetry_endangle()))
         return machine_slice
 
+    def get_forced_winding_slice(self):
+        logger.debug("get_forced_winding_slice()")
+        if not self.geom.is_outer:
+            return None
+
+        areas = len(self.geom.area_list)
+        winding_areas = self.geom.num_of_windings()
+        iron_areas = self.geom.num_of_irons()
+        air_areas = self.geom.num_areas_of_type((AREA.TYPE_AIR,))
+
+        if not (winding_areas + iron_areas + air_areas == areas):
+            logger.warning("Warning: strange areas in stator")
+
+        if winding_areas == 0:
+            return self.get_possible_windings()
+
+        if winding_areas < 2:
+            return None  # nothing to do
+        parts = self.get_winding_symmetry()
+        if parts < 2:
+            return None  # nothing to do
+        return self.get_symmetry_slice()
+
+    def get_possible_windings(self, EESM=False, single=False):
+        if not self.geom.is_outer:
+            return None
+
+        machine = self.clone()
+        machine.repair_hull()
+        machine.set_alfa_and_corners()
+        machine.geom.set_subregion_parameters(self.startangle,
+                                              self.endangle)
+        machine.geom.looking_for_corners()
+        dist_start = machine.geom.dist_start_min_corner()
+        dist_end = machine.geom.dist_end_min_corner()
+
+        if not np.isclose(dist_start, dist_end, rtol=1e-3, atol=1e-3):
+            angle = machine.geom.alfa
+            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.set_alfa_and_corners()
+            machine.part = machine.part_of_circle()
+            machine.geom.set_subregion_parameters(self.startangle,
+                                                  self.endangle)
+            machine.geom.looking_for_corners()
+
+        if machine.geom.close_outer_winding_areas():
+            machine.geom.create_list_of_areas(delete=True)
+            machine.geom.set_subregion_parameters(self.startangle,
+                                                  self.endangle)
+            machine.geom.looking_for_corners()
+            parts = machine.get_winding_symmetry(inside=True)
+
+            if parts == 1:
+                return machine
+            if parts > 1:
+                return machine.get_symmetry_slice()
+
+        return machine
+
+    def get_forced_magnet_slice(self):
+        logger.debug("get_forced_magnet_slice()")
+        areas = len(self.geom.area_list)
+        magnet_areas = self.geom.num_of_magnets()
+        iron_areas = self.geom.num_of_irons()
+        air_areas = self.geom.num_areas_of_type((AREA.TYPE_AIR,))
+
+        if magnet_areas < 2:
+            return None  # nothing to do
+        parts = self.get_magnet_symmetry()
+
+        if parts < 2:
+            return None  # nothing to do
+        slice = self.get_symmetry_slice()
+        match = slice.geom.min_max_corners_match()
+        while parts > 1 and not match:
+            parts = parts - 1
+            self.geom.rotate_symmetry_parameters()
+            slice = self.get_symmetry_slice()
+            match = slice.geom.min_max_corners_match()
+        if match:
+            slice.geom.set_rotor()
+            return slice
+        return None
+
     def get_forced_symmetry(self, part):
         logger.debug("begin get_forced_symmetry")
         if not self.is_full():
@@ -1041,6 +1163,13 @@ class Machine(object):
 
     def sync_with_counterpart(self, cp_machine):
         logger.debug("sync_with_counterpart")
+
+        def not_tiny_areas(geom):
+            sz_list = [a.area_size() for a in geom.list_of_areas()]
+            max_sz = max(sz_list)
+            large_sz_list = [sz for sz in sz_list if sz > max_sz * 0.005]
+            return len(large_sz_list)
+
         self.geom.sym_counterpart = cp_machine.get_symmetry_part()
         self.geom.sym_part = self.get_symmetry_part()
         logger.debug("part/sym-part: self=%s/%s, cp=%s/%s",
@@ -1049,6 +1178,14 @@ class Machine(object):
         cp_machine.geom.sym_counterpart = self.get_symmetry_part()
         cp_machine.geom.sym_part = cp_machine.get_symmetry_part()
 
+        if not_tiny_areas(self.geom) == 1:
+            if not_tiny_areas(cp_machine.geom) > 1:
+                self.geom.force_to_be_stator()
+                cp_machine.geom.force_to_be_rotor()
+        elif not_tiny_areas(cp_machine.geom) == 1:
+            self.geom.force_to_be_rotor()
+            cp_machine.geom.force_to_be_stator()
+
     def search_subregions(self, EESM, single=False):
         logger.debug("Search subregions")
         self.geom.search_subregions(self.startangle,
@@ -1073,8 +1210,7 @@ class Machine(object):
 
     def rebuild_subregions(self, EESM, single=False):
         logger.debug("Rebuild subregions")
-        self.geom.set_edge_attributes()
-        self.geom.area_list = []
+        self.geom.create_list_of_areas(delete=True)
         self.geom.search_subregions(self.startangle,
                                     self.endangle,
                                     EESM,
@@ -1142,6 +1278,11 @@ class Machine(object):
                                 self.endangle)
         return self.geom.windings_in_the_middle(midangle)
 
+    def has_magnets_in_the_middle(self):
+        midangle = middle_angle(self.startangle,
+                                self.endangle)
+        return self.geom.magnets_in_the_middle(midangle)
+
     def create_mirror_lines_outside_windings(self):
         logger.debug("create_mirror_lines_outside_windings")
 
@@ -1272,3 +1413,14 @@ class Machine(object):
             self.clear_cut_lines()
             self.repair_hull()
             self.set_alfa_and_corners()
+
+    def mirror_all_areas(self, mirror_angle):
+        self.geom.mirror_all_areas(mirror_angle)
+
+    def check_airgap_connecting_nodes(self, m_outer):
+        logger.info("check_airgap_connecting_nodes")
+        assert(self.geom.is_inner)
+        assert(m_outer.geom.is_outer)
+        self.geom.check_airgap_connecting_nodes(m_outer.geom,
+                                                self.startangle,
+                                                self.endangle)

femagtools/dxfsl/shape.py

@@ -11,7 +11,7 @@ from __future__ import print_function
 import numpy as np
 import logging
 from .functions import less_equal, greater_equal
-from .functions import distance, line_m, line_n
+from .functions import distance, line_m, line_n, mirror_point
 from .functions import point, points_are_close, points_on_arc
 from .functions import alpha_line, alpha_angle, alpha_triangle
 from .functions import normalise_angle, min_angle, max_angle, get_angle_of_arc
@@ -54,6 +54,9 @@ class Shape(object):
     def classname(self):
         return "Shape"
 
+    def clone(self):
+        return None
+
     def set_my_color(self, color):
         self.my_color = color
 
@@ -314,6 +317,32 @@ class Shape(object):
     def is_near(self, n):
         return False
 
+    def mirror_shape(self, geom_center, axis_m, axis_n):
+        n2 = mirror_point(self.start(), geom_center, axis_m, axis_n)
+        n1 = mirror_point(self.end(), geom_center, axis_m, axis_n)
+
+        el = None
+        if isinstance(self, Line):
+            el = Line(Element(start=n1, end=n2))
+
+        elif isinstance(self, Arc):
+            c = mirror_point(self.center, geom_center, axis_m, axis_n)
+            alpha1 = alpha_line(c, n1)
+            alpha2 = alpha_line(c, n2)
+            el = Arc(Element(center=c,
+                             radius=self.radius,
+                             start_angle=alpha1*180/np.pi,
+                             end_angle=alpha2*180/np.pi))
+
+        elif isinstance(self, Circle):
+            c = mirror_point(self.center, geom_center, axis_m, axis_n)
+            el = Circle(Element(center=c,
+                                radius=self.radius))
+
+        if el:
+            el.copy_attributes(self)
+        return el
+
     def print_nodes(self):
         return " n1={}/n2={}".format(self.n1, self.n2)
 
@@ -354,6 +383,10 @@ class Circle(Shape):
     def classname(self):
         return "Circle"
 
+    def clone(self):
+        return Circle(Element(center=self.center,
+                              radius=self.radius))
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -742,6 +775,14 @@ class Arc(Circle):
     def classname(self):
         return "Arc"
 
+    def clone(self):
+        alpha_start = alpha_line(self.center, self.p1)
+        alpha_end = alpha_line(self.center, self.p2)
+        return Arc(Element(center=self.center,
+                           radius=self.radius,
+                           start_angle=alpha_start*180/np.pi,
+                           end_angle=alpha_end*180/np.pi))
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -1285,6 +1326,10 @@ class Line(Shape):
     def classname(self):
         return "Line"
 
+    def clone(self):
+        return Line(Element(start=self.p1,
+                            end=self.p2))
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:

femagtools/dxfsl/svgparser.py

@@ -106,7 +106,7 @@ def svgshapes(svgfile):
     for p in svg.findall(".//{http://www.w3.org/2000/svg}path"):
         m = bcolor.search(p.get('style'))
         if m:
-            logger.info("subregion %d: %s", sr, m.groups()[0])
+            logger.debug("subregion %d: %s", sr, m.groups()[0])
         yield from get_shapes(p.get('d'))
         sr += 1
     for p in svg.findall(".//{http://www.w3.org/2000/svg}line"):

femagtools/dxfsl/symmetry.py

@@ -12,6 +12,7 @@ import logging
 import sys
 from femagtools.dxfsl.shape import Element, Line
 from femagtools.dxfsl.area import Area
+import femagtools.dxfsl.area as AREA
 from femagtools.dxfsl.functions import alpha_angle, positive_angle, is_same_angle
 from femagtools.dxfsl.functions import min_angle, max_angle, gcd, point
 from femagtools.dxfsl.functions import less_equal, less, points_are_close
@@ -100,41 +101,58 @@ class Symmetry(object):
         return positive_angle(alpha_angle(self.startangle,
                                           a.get_mid_angle(self.geom.center)))
 
-    def find_symmetry(self):
-        arealist = self.geom.list_of_areas()
-        logger.debug("begin of Symmetry::find_symmetry: %s areas available", len(arealist))
-        if len(arealist) == 0:
-            logger.debug("end of find_symmetry: no areas")
-            return 0
+    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),
+                self.calc_mid_angle(a),
+                a)
 
-        logger.debug("startangle=%s, endangle=%s", self.startangle, self.endangle)
+    def build_area_list(self, types=()):
+        arealist = self.geom.list_of_areas()
+        if types:
+            arealist = [a for a in arealist if a.type in types]
 
         areas = []
         for a in arealist:
-            areas.append((round(a.get_alpha(self.geom.center), 3),
-                          round(a.min_dist, 1),
-                          round(a.height, 1),
-                          self.calc_mid_angle(a),
-                          a))
+            areas.append(self.area_list_entry(a))
         areas.sort(reverse=True)
+        return areas
 
+    def build_results(self, 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
@@ -146,6 +164,89 @@ class Symmetry(object):
         rslt['area'] = a0
         rslt['areasize'] = areasize
         check_rslt.append((areasize, rslt))
+        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,))
+
+        logger.debug("begin of Symmetry::get_winding_symmetry: %s areas available", len(areas))
+        if not areas:
+            logger.debug("end of Symmetry::get_winding_symmetry: no areas")
+            return 0
+
+        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 <= 1:
+            return 0
+        self.create_cut_lines(parts, start_delta)
+
+        sym = self.geom_part * parts
+        delta = 2*np.pi/sym
+        self.set_symmetry_parameters(self.startangle, parts, delta)
+
+        logger.debug("end of Symmetry::get_winding_symmetry: parts=%s", parts)
+        return parts
+
+    def get_magnet_symmetry(self):
+        areas = self.build_area_list((AREA.TYPE_MAGNET_AIRGAP, AREA.TYPE_MAGNET_RECT,))
+        air = self.build_area_list((AREA.TYPE_AIR,))
+        mag_list = [a for a in self.geom.list_of_areas() if a.is_magnet()]
+        air_list = [a for a in self.geom.list_of_areas() if a.is_air()]
+        sz_list = [a.area_size() for a in self.geom.list_of_areas()]
+        max_sz = max(sz_list)
+        for a in air_list:
+            if a.area_size() < max_sz * 0.005:
+                continue
+            for m in mag_list:
+                if a.is_touching(m):
+                    areas.append(self.area_list_entry(a))
+                    break
+
+        logger.debug("begin of Symmetry::get_magnet_symmetry: %s areas available", len(areas))
+        if not areas:
+            logger.debug("end of Symmetry::get_magnet_symmetry: no areas")
+            return 0
+
+        check_rslt = self.build_results(areas)
+        logger.debug("%s results available", len(check_rslt))
+        [logger.debug("Result: %s", rslt) for rslt in check_rslt]
+        for sz, rslt in check_rslt:
+            if not rslt.get('startdelta', 0.0) == 0.0:
+                return 0  # not proper
+            if rslt.get('halfslice', None):
+                return 0  # not proper
+
+        parts, start_delta = self.get_symmetry_parts(check_rslt)
+        if parts <= 1:
+            return 0
+        self.create_cut_lines(parts, start_delta)
+
+        sym = self.geom_part * parts
+        delta = 2*np.pi/sym
+        self.set_symmetry_parameters(self.startangle, parts, delta)
+
+        logger.debug("end of Symmetry::get_magnet_symmetry: parts=%s", parts)
+        return parts
+
+    def find_symmetry(self):
+        areas = self.build_area_list()
+
+        logger.debug("begin of Symmetry::find_symmetry: %s areas available", len(areas))
+        if not areas:
+            logger.debug("end of Symmetry::find_symmetry: no areas")
+            return 0
+
+        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:
@@ -156,18 +257,7 @@ class Symmetry(object):
             self.startangle = self.startangle - self.delta_angle_corr
             self.endangle = self.endangle - self.delta_angle_corr
 
-        self.geom.clear_cut_lines()
-        for alpha in self.symmetry_lines(parts,
-                                         self.startangle,
-                                         start_delta,
-                                         self.endangle):
-            plus = self.geom.max_radius / 10
-            min_radius = max(10, self.geom.min_radius - plus)
-            p1 = point(self.geom.center, min_radius, alpha)
-            p2 = point(self.geom.center, self.geom.max_radius + plus, alpha)
-            line = Line(Element(start=p1, end=p2))
-            line.init_attributes(color='green')
-            self.geom.add_cut_line(line)
+        self.create_cut_lines(parts, start_delta)
 
         logger.debug("end of Symmetry::find_symmetry: -> %s", parts)
         return parts
@@ -177,6 +267,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
@@ -375,9 +466,6 @@ class Symmetry(object):
 
                     dlist = []
                     x = 0
-                    # logger.info("inx: %s", inx)
-                    # [logger.info("%s deltas: %s", n, d) for n, d in deltas]
-                    # [logger.info("area: %s", m) for m, a in area_list]
 
                     for i in inx:
                         for n in range(x, i):
@@ -833,6 +921,20 @@ class Symmetry(object):
         logger.debug("return %s parts", parts)
         return parts
 
+    def create_cut_lines(self, parts, start_delta):
+        self.geom.clear_cut_lines()
+        for alpha in self.symmetry_lines(parts,
+                                         self.startangle,
+                                         start_delta,
+                                         self.endangle):
+            plus = self.geom.max_radius / 10
+            min_radius = max(10, self.geom.min_radius - plus)
+            p1 = point(self.geom.center, min_radius, alpha)
+            p2 = point(self.geom.center, self.geom.max_radius + plus, alpha)
+            line = Line(Element(start=p1, end=p2))
+            line.init_attributes(color='green')
+            self.geom.add_cut_line(line)
+
     def symmetry_lines(self, parts, startangle, start_delta, endangle):
         logger.debug("begin symmetry_lines from %s to %s with start %s",
                      startangle,
@@ -858,14 +960,17 @@ class Symmetry(object):
             yield start
 
         # Damit man anschliessend ohne Umstände schneiden kann.
-        self.geom.sym_startangle = sym_startangle
-        self.geom.sym_endangle = sym_startangle + delta
+        self.set_symmetry_parameters(sym_startangle, parts, delta)
+        logger.debug("end symmetry_lines")
+
+    def set_symmetry_parameters(self, startangle, parts, delta):
+        self.geom.sym_startangle = startangle
+        self.geom.sym_endangle = startangle + delta
         self.geom.sym_slices = parts
         self.geom.sym_slice_angle = delta
         self.geom.sym_area = Area([], (0,0), 0.0)
         self.geom.sym_area.sym_startangle = self.geom.sym_startangle
         self.geom.sym_area.sym_endangle = self.geom.sym_endangle
-        logger.debug("end symmetry_lines")
 
     def check_symmetry_of_mirror(self, mirror_geom, mirrorangle):
         logger.debug("begin of Symmetry::check_symmetry_of_mirror")