femagtools 1.7.5__tar.gz → 1.7.6__tar.gz

{femagtools-1.7.5/src/femagtools.egg-info → femagtools-1.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: femagtools
-Version: 1.7.5
+Version: 1.7.6
 Summary: Python API for FEMAG
 Author-email: Ronald Tanner <tar@semafor.ch>, Dapu Zhang <dzhang@gtisoft.com>, Beat Holm <hob@semafor.ch>, Günther Amsler <amg@semafor.ch>, Nicolas Mauchle <mau@semafor.ch>
 License: Copyright (c) 2016-2023, Semafor Informatik & Energie AG, Basel

{femagtools-1.7.5 → femagtools-1.7.6}/src/femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.7.5'
+__version__ = '1.7.6'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2024 Gamma Technology'

{femagtools-1.7.5 → femagtools-1.7.6}/src/femagtools/dxfsl/area.py

@@ -40,6 +40,8 @@ TYPE_MAGNET_OR_IRON = 9
 TYPE_SHAFT = 10
 TYPE_MAGNET_RECT_NEAR_AIRGAP = 11
 TYPE_WINDINGS_OR_AIR = 12
+TYPE_WINDINGS_OR_IRON = 13
+TYPE_FD_WINDINGS = 15
 TYPE_MAGNET_UNDEFINED = 99
 TYPE_GROUP = 20
 
@@ -206,6 +208,8 @@ class Area(object):
             return 'Iron'
         if self.type == TYPE_WINDINGS:
             return 'Windings'
+        if self.type == TYPE_FD_WINDINGS:
+            return 'Field Windings'
         if self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT:
             return 'Magnet'
         if self.type == TYPE_YOKE:
@@ -221,6 +225,8 @@ class Area(object):
             return 'Iron'
         if self.type == TYPE_WINDINGS:
             return 'Wndg'
+        if self.type == TYPE_FD_WINDINGS:
+            return 'FD_Wndg'
         if self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT:
             return 'Mag'
         if self.type == TYPE_YOKE:
@@ -236,6 +242,8 @@ class Area(object):
             return 'cyan'
         if self.type == TYPE_WINDINGS:
             return 'green'
+        if self.type == TYPE_FD_WINDINGS:
+            return 'yellow'
         if self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT:
             return 'red'
         if self.type == TYPE_YOKE:
@@ -251,6 +259,8 @@ class Area(object):
             return 0.3
         if self.type == TYPE_WINDINGS:
             return 1.0
+        if self.type == TYPE_FD_WINDINGS:
+            return 1.0
         if self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT:
             return 1.0
         if self.type == TYPE_YOKE:
@@ -277,7 +287,9 @@ class Area(object):
         return self.type == TYPE_IRON
 
     def is_winding(self):
-        return self.type == TYPE_WINDINGS
+        return \
+            self.type == TYPE_WINDINGS or \
+            self.type == TYPE_FD_WINDINGS
 
     def is_magnet(self):
         return self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT
@@ -324,6 +336,17 @@ class Area(object):
             return True
         return False
 
+    def minmax_dist_from_center(self, center):
+        rmin = 1e20
+        rmax = 0
+        for n in self.list_of_nodes():
+            r = np.linalg.norm(np.array(n)-center)
+            if r < rmin:
+                rmin = r
+            if r > rmax:
+                rmax = r
+        return rmin, rmax
+
     def minmax_angle_dist_from_center(self, center, dist):
         circ = Circle(Element(center=center, radius=dist))
         s = self.area[0]
@@ -1315,11 +1338,89 @@ class Area(object):
         logger.debug("***** air #4\n")
         return 0
 
-    def mark_rotor_subregions(self, is_inner, mirrored, alpha,
-                              center, r_in, r_out,
-                              startangle,
-                              endangle):
-        logger.debug("mark_rotor_subregions")
+    def mark_EESM_rotor_subregions(self,
+                                   is_inner,
+                                   mirrored,
+                                   alpha,
+                                   center,
+                                   r_in,
+                                   r_out,
+                                   startangle,
+                                   endangle):
+        logger.debug("mark_EESM_rotor_subregions")
+
+        alpha = round(alpha, 6)
+
+        if self.is_circle():
+            self.type = TYPE_AIR  # air
+            logger.debug(">>> air is a circle")
+            return self.type
+
+        if is_inner:
+            self.close_to_ag = np.isclose(r_out, self.max_dist, rtol=1e-9, atol=0.005)
+            close_to_opposition = greater_equal(r_in * 1.05, self.min_dist)
+            airgap_radius = r_out
+            opposite_radius = r_in
+            airgap_toleranz = -(self.max_dist - self.min_dist) / 50.0  # 2%
+        else:
+            self.close_to_ag = np.isclose(r_in, self.min_dist, rtol=1e-9, atol=0.005)
+            close_to_opposition = greater_equal(self.max_dist * 1.05, r_out)
+            airgap_radius = r_in
+            opposite_radius = r_out
+            airgap_toleranz = (self.max_dist - self.min_dist) / 50.0  # 2%
+
+        self.close_to_startangle = np.isclose(self.min_angle, startangle,
+                                              1e-04, 1e-04)
+        self.close_to_endangle = np.isclose(self.max_angle, endangle,
+                                            1e-04, 1e-04)
+
+        logger.debug("\n***** mark_EESM_rotor_subregions [{}] *****"
+                     .format(self.id))
+        logger.debug(" - close_to_ag        : %s", self.close_to_ag)
+        logger.debug(" - close_to_opposition: %s", close_to_opposition)
+        logger.debug(" - min dist           : %3.12f", self.min_dist)
+        logger.debug(" - max dist           : %3.12f", self.max_dist)
+        logger.debug(" - airgap radius      : %3.12f", airgap_radius)
+        logger.debug(" - opposite radius    : %3.12f", opposite_radius)
+        logger.debug(" - close_to_startangle: %s", self.close_to_startangle)
+        logger.debug(" - close_to_endangle  : %s", self.close_to_endangle)
+        logger.debug(" - alpha              : %3.12f", alpha)
+        logger.debug(" - min_angle          : %3.12f", self.min_angle)
+        logger.debug(" - max_angle          : %3.12f", self.max_angle)
+
+        if self.has_iron_separator():
+            logger.debug("***** iron (has iron separator)\n")
+            self.type = TYPE_IRON  # iron
+            return self.type
+
+        if is_inner:
+            # looking for shaft
+            if close_to_opposition and not self.close_to_ag:
+                logger.debug("-- check for shaft")
+                if self.is_shaft_area(center):
+                    self.type = TYPE_SHAFT  # shaft
+                    logger.debug("***** shaft (close to opposition)\n")
+                    return self.type
+
+        if close_to_opposition or self.close_to_ag:
+            self.type = TYPE_IRON  # iron
+            logger.debug("***** iron (close to opposition)\n")
+            return self.type
+
+        self.type = TYPE_WINDINGS_OR_IRON  # windings or iron
+        logger.debug("***** air (somewhere)\n")
+        return self.type
+
+    def mark_PMSM_rotor_subregions(self,
+                                   is_inner,
+                                   mirrored,
+                                   alpha,
+                                   center,
+                                   r_in,
+                                   r_out,
+                                   startangle,
+                                   endangle):
+        logger.debug("mark_PMSM_rotor_subregions")
 
         alpha = round(alpha, 6)
 
@@ -1346,7 +1447,7 @@ class Area(object):
         self.close_to_endangle = np.isclose(self.max_angle, endangle,
                                             1e-04, 1e-04)
 
-        logger.debug("\n***** mark_rotor_subregions [{}] *****"
+        logger.debug("\n***** mark_PMSM_rotor_subregions [{}] *****"
                      .format(self.id))
         logger.debug(" - close_to_ag        : %s", self.close_to_ag)
         logger.debug(" - close_to_opposition: %s", close_to_opposition)

{femagtools-1.7.5 → femagtools-1.7.6}/src/femagtools/dxfsl/conv.py

@@ -25,6 +25,16 @@ def main():
         description='Process DXF file and create a plot or FSL file.')
     argparser.add_argument('dxfile',
                            help='name of DXF file')
+    argparser.add_argument('--PMSM',
+                           help='Permanent Magnet Synchronous Motor',
+                           dest='PMSM',
+                           action="store_true",
+                           default=False)
+    argparser.add_argument('--EESM',
+                           help='Electric Excited Synchronous Motor',
+                           dest='EESM',
+                           action="store_true",
+                           default=False)
     argparser.add_argument('--inner',
                            help='name of inner element',
                            dest='inner',
@@ -209,12 +219,17 @@ def main():
         if args.sym_part not in (3, 4, 6, 8):
             logger.error("Argument sympart not in (3, 4, 6, 8)")
             sys.exit(1)
+    if args.EESM:
+        if args.PMSM:
+            logger.error("PMSM or EESM expected (default PMSM)")
+            sys.exit(1)
 
     if not args.write_fsl:
         if not (args.show_plots or args.show_areas or args.view):
             args.write_fsl = True
 
     res = convert(args.dxfile,  # DXF-Filename
+                  args.EESM,    # motor type EESM or PMSM
                   rtol=args.rtol,    # relative pickdist toleranz
                   atol=args.atol,    # absolute pickdist toleranz
                   symtol=args.sym_tolerance,

{femagtools-1.7.5 → femagtools-1.7.6}/src/femagtools/dxfsl/converter.py

@@ -158,7 +158,7 @@ def symmetry_search(machine,
     return machine_ok
 
 
-def build_machine_rotor(machine, inner, mindist, plt, single=False):
+def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
     logger.debug("Begin of build_machine_rotor")
     if machine.has_windings():
         logger.debug("do nothing here with windings in rotor")
@@ -170,7 +170,7 @@ def build_machine_rotor(machine, inner, mindist, plt, single=False):
         machine_temp = machine.undo_mirror()
         machine_temp.delete_tiny_elements(mindist)
         machine_temp.geom.set_rotor()
-        machine_temp.search_rotor_subregions(single=single)
+        machine_temp.search_rotor_subregions(EESM, single=single)
     else:
         machine_temp = machine
 
@@ -199,7 +199,7 @@ def build_machine_rotor(machine, inner, mindist, plt, single=False):
         logger.debug("Auxiliary Lines created: rebuild subregions")
         rebuild = True
     if rebuild:
-        machine_temp.rebuild_subregions(single=single)
+        machine_temp.rebuild_subregions(EESM, single=single)
 
     machine_temp.geom.recalculate_magnet_orientation()
     if inner:
@@ -215,7 +215,7 @@ def build_machine_rotor(machine, inner, mindist, plt, single=False):
     return machine_temp
 
 
-def build_machine_stator(machine, inner, mindist, plt, single=False):
+def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False):
     logger.debug("Begin of build_machine_stator")
     if not machine.geom.is_stator():
         logger.debug("Rotor with windings")
@@ -230,7 +230,7 @@ def build_machine_stator(machine, inner, mindist, plt, single=False):
     else:
         machine_temp = machine
     if machine_temp.create_auxiliary_lines():
-        machine_temp.rebuild_subregions(single=single)
+        machine_temp.rebuild_subregions(EESM, single=single)
 
     if inner:
         machine_temp.create_inner_corner_areas()
@@ -246,6 +246,7 @@ def build_machine_stator(machine, inner, mindist, plt, single=False):
 
 
 def convert(dxfile,
+            EESM=False,
             rtol=1e-04,
             atol=1e-03,
             mindist=0.01,
@@ -505,34 +506,38 @@ def convert(dxfile,
 
         machine_inner.sync_with_counterpart(machine_outer)
 
-        machine_inner.search_subregions()
-        machine_outer.search_subregions()
+        machine_inner.search_subregions(EESM)
+        machine_outer.search_subregions(EESM)
 
         # Inner mirrored rotor
         if machine_inner.geom.is_rotor():
             machine_inner = build_machine_rotor(machine_inner,
                                                 True,  # is inner
                                                 mindist,
-                                                p)
+                                                p,
+                                                EESM=EESM)
 
         # Outer mirrored rotor
         if machine_outer.geom.is_rotor():
             machine_outer = build_machine_rotor(machine_outer,
                                                 False,  # is outer
                                                 mindist,
-                                                p)
+                                                p,
+                                                EESM=EESM)
 
         if machine_inner.geom.is_stator() or machine_inner.has_windings():
             machine_inner = build_machine_stator(machine_inner,
                                                  True,
                                                  mindist,
-                                                 p)
+                                                 p,
+                                                 EESM=EESM)
 
         if machine_outer.geom.is_stator() or machine_outer.has_windings():
             machine_outer = build_machine_stator(machine_outer,
                                                  False,
                                                  mindist,
-                                                 p)
+                                                 p,
+                                                 EESM=EESM)
         machine_inner.sync_with_counterpart(machine_outer)
 
         machine_inner.search_critical_elements(mindist)
@@ -707,20 +712,30 @@ def convert(dxfile,
                 machine.geom.set_stator()
                 machine.set_inner_or_outer(part[1])
                 machine.search_stator_subregions(single=True)
-                machine = build_machine_stator(machine, inner, mindist, p, single=True)
+                machine = build_machine_stator(machine,
+                                               inner,
+                                               mindist,
+                                               p,
+                                               EESM=EESM,
+                                               single=True)
 
                 params = create_femag_parameters_stator(machine,
                                                         part[1])
             else:
                 machine.geom.set_rotor()
                 machine.set_inner_or_outer(part[1])
-                machine.search_rotor_subregions(single=True)
-                machine = build_machine_rotor(machine, inner, mindist, p, single=True)
+                machine.search_rotor_subregions(EESM, single=True)
+                machine = build_machine_rotor(machine,
+                                              inner,
+                                              mindist,
+                                              p,
+                                              EESM=EESM,
+                                              single=True)
 
                 params = create_femag_parameters_rotor(machine,
                                                        part[1])
         else:
-            machine.search_subregions(single=True)
+            machine.search_subregions(EESM, single=True)
 
         machine.create_inner_corner_areas()
 

{femagtools-1.7.5 → femagtools-1.7.6}/src/femagtools/dxfsl/fslrenderer.py

@@ -254,6 +254,9 @@ class FslRenderer(object):
                     if area.type not in subregions:
                         subregions[area.type] = 1
                     num_windings += 1
+                    rmin, rmax = area.minmax_dist_from_center((0,0))
+                    self.content.append(
+                        f'rcoil_{num_windings} = {rmin}, {rmax}')
                     self.content.append('m.xcoil_{}, m.ycoil_{} = x0, y0'.
                                         format(num_windings, num_windings))
 

{femagtools-1.7.5 → femagtools-1.7.6}/src/femagtools/dxfsl/geom.py

@@ -3040,11 +3040,20 @@ class Geometry(object):
                     for e in elist:
                         e.init_attributes('lightblue', 'no_fsl')
 
-    def search_subregions(self, startangle, endangle, single=False):
+    def search_subregions(self, startangle, endangle, EESM, single=False):
         if self.is_stator():
-            self.search_stator_subregions(startangle, endangle, single=single)
+            self.search_stator_subregions(startangle,
+                                          endangle,
+                                          single=single)
         elif self.is_rotor():
-            self.search_rotor_subregions(startangle, endangle, single=single)
+            if EESM:
+                self.search_EESM_rotor_subregions(startangle,
+                                                  endangle,
+                                                  single=single)
+            else:
+                self.search_PMSM_rotor_subregions(startangle,
+                                                  endangle,
+                                                  single=single)
         else:
             logger.warning("no stator or rotor assigned")
             self.search_unknown_subregions()
@@ -3262,25 +3271,88 @@ class Geometry(object):
             self.check_shaft_area(shaft_areas[0])
         logger.debug("End of search_stator_subregions")
 
-    def search_rotor_subregions(self,
-                                startangle,
-                                endangle,
-                                single=False):
-        logger.debug("Begin of search_rotor_subregions")
+    def search_EESM_rotor_subregions(self,
+                                     startangle,
+                                     endangle,
+                                     single=False):
+        logger.debug("Begin of search_EESM_rotor_subregions")
+
+        if self.alfa == 0.0:
+            self.alfa = np.pi * 2.0
+
+        types = {}
+        for area in self.list_of_areas():
+            t = area.mark_EESM_rotor_subregions(self.is_inner,
+                                                self.is_mirrored(),
+                                                self.alfa,
+                                                self.center,
+                                                self.min_radius,
+                                                self.max_radius,
+                                                startangle,
+                                                endangle)
+            if t in types:
+                types[t] += 1
+            else:
+                types[t] = 1
+
+        windings = [a for a in self.list_of_areas()
+                    if a.is_type(AREA.TYPE_WINDINGS_OR_IRON)]
+
+        if self.is_mirrored():
+            [a.set_type(AREA.TYPE_IRON) for a in windings
+             if a.close_to_endangle]
+            wlist = [(a.max_angle, a) for a in self.list_of_areas()
+                     if a.is_type(AREA.TYPE_WINDINGS_OR_IRON)]
+            if wlist:
+                wlist.sort(reverse=True)
+                a, w = wlist[0]
+                w.set_type(AREA.TYPE_FD_WINDINGS)
+        else:
+            midangle = middle_angle(startangle, endangle)
+            [a.set_type(AREA.TYPE_IRON) for a in windings
+             if a.max_angle > midangle and a.min_angle < midangle]
+            windings = [a for a in self.list_of_areas()
+                        if a.is_type(AREA.TYPE_WINDINGS_OR_IRON)]
+            if len(windings) > 1:
+                wlist = []
+                for w in windings:
+                    if w.max_angle < midangle:
+                        angle = alpha_angle(w.max_angle, midangle)
+                    else:
+                        angle = alpha_angle(midangle, w.min_angle)
+                    wlist.append((angle, w))
+                wlist.sort()
+                a1, w1 = wlist[0]
+                a2, w2 = wlist[1]
+                if np.isclose(a1, a2):
+                    w1.set_type(AREA.TYPE_FD_WINDINGS)
+                    w2.set_type(AREA.TYPE_FD_WINDINGS)
+
+        # all remaining areas are in iron
+        [a.set_type(AREA.TYPE_IRON) for a in self.list_of_areas()
+         if a.is_type(AREA.TYPE_WINDINGS_OR_IRON)]
+
+        logger.debug("End of search_EESM_rotor_subregions")
+
+    def search_PMSM_rotor_subregions(self,
+                                     startangle,
+                                     endangle,
+                                     single=False):
+        logger.debug("Begin of search_PMSM_rotor_subregions")
 
         if self.alfa == 0.0:
             self.alfa = np.pi * 2.0
 
         types = {}
         for area in self.list_of_areas():
-            t = area.mark_rotor_subregions(self.is_inner,
-                                           self.is_mirrored(),
-                                           self.alfa,
-                                           self.center,
-                                           self.min_radius,
-                                           self.max_radius,
-                                           startangle,
-                                           endangle)
+            t = area.mark_PMSM_rotor_subregions(self.is_inner,
+                                                self.is_mirrored(),
+                                                self.alfa,
+                                                self.center,
+                                                self.min_radius,
+                                                self.max_radius,
+                                                startangle,
+                                                endangle)
             if t in types:
                 types[t] += 1
             else:
@@ -3408,7 +3480,7 @@ class Geometry(object):
                 self.search_stator_subregions(startangle, endangle, single=single)
             return
 
-        logger.debug("end of search_rotor_subregions")
+        logger.debug("end of search_PMSM_rotor_subregions")
 
     def recalculate_magnet_orientation(self):
         logger.debug("begin of recalculate_magnet_orientation")

{femagtools-1.7.5 → femagtools-1.7.6}/src/femagtools/dxfsl/machine.py

@@ -1046,21 +1046,36 @@ class Machine(object):
         cp_machine.geom.sym_counterpart = self.get_symmetry_part()
         cp_machine.geom.sym_part = cp_machine.get_symmetry_part()
 
-    def search_subregions(self, single=False):
+    def search_subregions(self, EESM, single=False):
         logger.debug("Search subregions")
-        self.geom.search_subregions(self.startangle, self.endangle, single=single)
-
-    def search_rotor_subregions(self, single=False):
-        self.geom.search_rotor_subregions(self.startangle, self.endangle, single=single)
+        self.geom.search_subregions(self.startangle,
+                                    self.endangle,
+                                    EESM,
+                                    single=single)
+
+    def search_rotor_subregions(self, EESM, single=False):
+        if EESM:
+            self.geom.search_EESM_rotor_subregions(self.startangle,
+                                                   self.endangle,
+                                                   single=single)
+        else:
+            self.geom.search_PMSM_rotor_subregions(self.startangle,
+                                                   self.endangle,
+                                                   single=single)
 
     def search_stator_subregions(self, single=False):
-        self.geom.search_stator_subregions(self.startangle, self.endangle, single=single)
+        self.geom.search_stator_subregions(self.startangle,
+                                           self.endangle,
+                                           single=single)
 
-    def rebuild_subregions(self, single=False):
+    def rebuild_subregions(self, EESM, single=False):
         logger.debug("Rebuild subregions")
         self.geom.set_edge_attributes()
         self.geom.area_list = []
-        self.geom.search_subregions(self.startangle, self.endangle, single=single)
+        self.geom.search_subregions(self.startangle,
+                                    self.endangle,
+                                    EESM,
+                                    single=single)
 
     def has_windings(self):
         return self.geom.has_windings
@@ -1170,7 +1185,9 @@ class Machine(object):
             self.geom.area_list = []
             logger.debug("create subregions again")
             self.geom.create_list_of_areas()
-            self.geom.search_subregions(self.startangle, self.endangle)
+            self.geom.search_subregions(self.startangle,
+                                        self.endangle,
+                                        False)
 
         logger.debug("end create_mirror_lines_outside_windings")
 

{femagtools-1.7.5 → femagtools-1.7.6}/src/femagtools/fsl.py

@@ -768,7 +768,10 @@ class Builder:
 
         return (fslmodel + self.create_analysis(sim) +
                 ['save_model("close")'])
-
+    
+    def create_detailed_wire(self, params, templ): 
+        return self.__render(params, templ)
+    
     def __render(self, model, templ, stator=False, magnet=False):
         if templ.split('.')[-1] in ('fsl', 'mako'):
             try: