femagtools 1.7.5__py3-none-any.whl → 1.7.7__py3-none-any.whl

femagtools/__init__.py

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

femagtools/bch.py

@@ -62,9 +62,12 @@ def sttylosses(losses):
             d['stteeth'] = losses[teeth]
         try:
             d['styoke_hyst'] = losses[yoke+'_hyst']
-            d['stteeth_hyst'] = losses[teeth+'_hyst']
             d['styoke_eddy'] = losses[yoke+'_eddy']
+            d['stteeth_hyst'] = losses[teeth+'_hyst']
             d['stteeth_eddy'] = losses[teeth+'_eddy']
+        except KeyError:
+            pass
+        try:
             d['styoke_excess'] = losses[yoke+'_excess']
             d['stteeth_excess'] = losses[teeth+'_excess']
         except KeyError:
@@ -306,6 +309,13 @@ class Reader:
                      'torque': tq.tolist()}]
         except (KeyError, IndexError):
             pass
+        
+        # check number of phases
+        try: 
+            if 'm' not in self.machine:
+                self.machine['m'] = len(self.current_angles)
+        except: 
+            pass
 
         return self
 

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/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/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)
@@ -635,7 +640,8 @@ def convert(dxfile,
                 logger.warning("it's not possible to create fsl-file")
                 return None
 
-            fslrenderer = FslRenderer(basename)
+            mtype = 'EESM' if EESM else 'PMSM'
+            fslrenderer = FslRenderer(basename, mtype)
             inner = fslrenderer.render(machine_inner, inner=True)
             outer = fslrenderer.render(machine_outer, outer=True)
             if full_model:
@@ -647,14 +653,13 @@ def convert(dxfile,
                                       params.get('nodedist'))
 
             if params['external_rotor']:
-                conv['fsl_magnet'] = outer
+                conv['fsl_rotor'] = outer
                 conv['fsl_stator'] = inner
             else:
-                conv['fsl_magnet'] = inner
+                conv['fsl_rotor'] = inner
                 conv['fsl_stator'] = outer
 
             conv['fsl'] = fslrenderer.render_main(
-                machine,
                 machine_inner, machine_outer,
                 inner, outer,
                 params)
@@ -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()
 
@@ -776,7 +791,8 @@ def convert(dxfile,
                 logger.warning("it's not possible to create fsl-file")
                 return None
 
-            fslrenderer = FslRenderer(basename)
+            mtype = 'EESM' if EESM else 'PMSM'
+            fslrenderer = FslRenderer(basename, mtype)
             conv['fsl'] = fslrenderer.render(machine, inner, outer)
 
     if params is not None:
@@ -800,13 +816,18 @@ def create_femag_parameters(m_inner, m_outer, nodedist=1):
     parts_inner = int(m_inner.get_symmetry_part())
     parts_outer = int(m_outer.get_symmetry_part())
 
+    slot_area = 0
     if parts_inner > parts_outer:
+        from .area import TYPE_WINDINGS
+        slot_area = geom_inner.area_size_of_type(TYPE_WINDINGS)
         num_slots = int(parts_inner)
         num_poles = int(parts_outer)
         num_sl_gen = int(geom_inner.get_symmetry_copies()+1)
         alfa_slot = geom_inner.get_alfa()
         alfa_pole = geom_outer.get_alfa()
     else:
+        from .area import TYPE_WINDINGS
+        slot_area = geom_outer.area_size_of_type(TYPE_WINDINGS)
         num_slots = int(parts_outer)
         num_poles = int(parts_inner)
         num_sl_gen = int(geom_outer.get_symmetry_copies()+1)
@@ -814,6 +835,7 @@ def create_femag_parameters(m_inner, m_outer, nodedist=1):
         alfa_pole = geom_inner.get_alfa()
 
     params['tot_num_slot'] = num_slots
+    params['slot_area'] = slot_area
     params['num_sl_gen'] = num_sl_gen
     params['num_poles'] = num_poles
     params['nodedist'] = nodedist
@@ -851,6 +873,7 @@ def create_femag_parameters_stator(motor, position):
     else:
         params['dy1'] = 2*motor.geom.max_radius
         params['da1'] = 2*motor.geom.min_radius
+    params['slot_area'] = motor.slot_area()
     return params
 
 
@@ -864,4 +887,5 @@ def create_femag_parameters_rotor(motor, position):
     else:
         params['dy1'] = 2*motor.geom.max_radius
         params['da1'] = 2*motor.geom.min_radius
+    params['slot_area'] = motor.slot_area()
     return params