femagtools 1.7.4__py3-none-any.whl → 1.7.6__py3-none-any.whl

femagtools/__init__.py

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

femagtools/bch.py

@@ -613,6 +613,7 @@ class Reader:
 
     def __read_general_machine_data(self, content):
         mcfiles = []
+        slotsides = 1
         for l in content:
             try:
                 if l.find('Armature Length') > -1:
@@ -631,8 +632,10 @@ class Reader:
                     self.machine['p_sim'] = int(l.split()[-1])
                 elif l.find('Total Number of Slots') > -1:
                     self.machine['Q'] = int(l.split()[-1])
+                elif l.find('Total Number of Slot-Sides') > -1:
+                    slotsides = int(l.split()[-1])
                 elif l.find('Number of Slot-Sides sim.') > -1:
-                    self.machine['qs_sim'] = int(l.split()[-1])
+                    self.machine['qs_sim'] = int(l.split()[-1])*self.machine['Q']//slotsides
                 elif l.find('POC-File used in calculation') > -1:
                     self.machine['pocfile'] = l.split(
                         ':')[-1].strip().replace('\\', '\\\\')

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
 
@@ -84,6 +86,7 @@ class Area(object):
         self.is_child = False
         self.areas_inside = {}
         self.areas_of_group = []
+        self.group_is_inside = False
 
     def identifier(self):
         return "{}-{}".format(self.id, self.type)
@@ -205,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:
@@ -220,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:
@@ -235,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:
@@ -250,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:
@@ -276,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
@@ -323,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]
@@ -1314,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)
 
@@ -1345,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)
@@ -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/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/dxfsl/geom.py

@@ -2478,7 +2478,8 @@ class Geometry(object):
             groups_inside = {g.id: g for g in grouplist}
             area.areas_inside = groups_inside
             areas_outside.append(area)
-            for g in  grouplist:
+            for g in grouplist:
+                g.group_is_inside = True
                 alist = groups.get(g.id, [])
                 alist.append(area)
                 groups[g.id] = alist
@@ -2532,6 +2533,11 @@ class Geometry(object):
             for area in area_list:
                 if self.create_aux_lines(area, rightangle, leftangle):
                     done = True
+            main_groups = [g for g in self.areagroup_list
+                           if not g.group_is_inside]
+            if len(main_groups) > 1:
+                if self.create_outside_aux_lines(main_groups):
+                    done = True
         else:
             logger.debug("-> start create_auxiliary_lines")
             self.set_areas_inside_for_all_areas()
@@ -2856,6 +2862,38 @@ class Geometry(object):
                      area.get_id())
         return done
 
+    def create_outside_aux_lines(self, grouplist):
+        done = False
+        aux_color = 'blue'
+        aux_linestyle = 'dotted'
+
+        i = 0
+        gaps = []
+        for group in grouplist:
+            i += 1
+            for g in grouplist[i:]:
+                gaps += group.get_lowest_gap_list(g,
+                                                  self.center, self.max_radius,
+                                                  None, None)
+        gaps.sort()
+
+        l = len(grouplist) -1
+        for d, points, token, id in gaps[:l]:
+            logger.info("Token %s", token)
+            line = Line(Element(start=points[0],
+                                end=points[1]),
+                                color=aux_color,
+                                linestyle=aux_linestyle,
+                                attr='outside_auxline')
+            n1 = self.find_the_node(line.node1(ndec))
+            n2 = self.find_the_node(line.node2(ndec))
+            if n1 and n2:
+                self.add_element(line,
+                                 rtol=self.rtol,
+                                 atol=self.atol)
+                done = True
+        return done
+
     def set_rotor(self):
         self.sym_counterpart = 1
         self.sym_part = 0
@@ -3002,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()
@@ -3224,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:
@@ -3370,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/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/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:

femagtools/machine/pm.py

@@ -5,7 +5,7 @@ import logging
 import warnings
 import numpy as np
 import numpy.linalg as la
-from .utils import iqd, betai1, skin_resistance, dqparident, KTH, K
+from .utils import iqd, betai1, skin_resistance, dqparident, KTH, K, T
 import scipy.optimize as so
 import scipy.interpolate as ip
 import scipy.integrate as ig
@@ -14,6 +14,38 @@ from functools import partial
 logger = logging.getLogger(__name__)
 
 
+def find_peaks_and_valleys(t, iabc, tshort):
+    """ return peaks and valleys of phase current with maximum amplitude
+    """
+    iph = iabc[np.argmax([np.max(np.abs(iph))
+                          for iph in iabc])]
+    ts = t[t>tshort]
+    Z = iph[t>tshort]
+    peaks = (np.diff(np.sign(np.diff(Z))) < 0).nonzero()[0] + 1
+    if len(peaks>0):
+        p = {'ip': Z[peaks].tolist(), 'tp': ts[peaks].tolist()}
+    else:
+        p = {'ip': [], 'tp': []}
+    valleys = (np.diff(np.sign(np.diff(Z))) > 0).nonzero()[0] + 1
+    if len(valleys>0):
+        v = {'iv': Z[valleys].tolist(), 'tv': ts[valleys].tolist()}
+    else:
+        v = {'iv': [], 'tv': []}
+    try:
+        cs = ip.CubicSpline(ts[peaks], Z[peaks])
+        p.update({'i': cs(ts).tolist(), 't': ts.tolist()})
+    except ValueError as e:
+        logger.warning("no peaks in current: %d",
+                       len(peaks))
+    try:
+        cs = ip.CubicSpline(ts[valleys], Z[valleys])
+        v.update({'i': cs(ts).tolist(), 't': ts.tolist()})
+    except ValueError as e:
+        logger.warning("no valleys in current: %d",
+                       len(valleys))
+    return p, v
+
+
 def parident(workdir, engine, temp, machine,
              magnetizingCurves, magnetMat, condMat,
              **kwargs):
@@ -1487,68 +1519,184 @@ class PmRelMachinePsidq(PmRelMachine):
     def betai1_plmag(self, beta, i1, f1):
         return self.iqd_plmag(*iqd(beta, i1), f1)
 
+    def ldlqpsim(self):
+        def ext_array(id, iq, a):
+            """extend array a if current is 0 at edge
+            id: list of n id values
+            iq: list of m iq values
+            a: nxm array to extend"""
+            if id[0] == 0:
+                y = np.array(a)[:, 1].reshape((-1, 1))
+                m = np.hstack((y, a))
+            elif id[-1] == 0:
+                y = np.array(a)[:, -2].reshape((-1, 1))
+                m = np.hstack((a, y))
+            else:
+                m = np.array(a)
+
+            if iq[0] == 0:
+                return np.concatenate(([m[1]], m))
+            elif iq[-1] == 0:
+                return np.concatenate((m, [m[-2]]))
+
+            return m
+
+        idn = np.append(self.id, -self.id[-2])
+        iqz = np.where(self.iq == 0.)[0][0]
+        if iqz in {0, len(self.iq)-1}:
+            iqn = np.insert(self.iq, 0, -self.iq[1])
+        elif iqz == len(self.iq)-1:
+            iqn = np.append(self.iq, -self.iq[iqz-1])
+        else:
+            iqn = np.array(self.iq)
+        psid2 = ext_array(self.id, self.iq, self.psid)
+        psiq2 = ext_array(self.id, self.iq, self.psiq)
+
+        # create n x m matrix of currents
+        id = np.ones(psid2.shape) * idn
+        iq = (np.ones(psid2.shape).T * iqn).T
+
+        # calculate ec model parameters
+        psim = (np.ones(psid2.shape).T * psid2[id == 0.]).T
+        nz = np.any(id != 0., axis=0)
+        ld = ((psid2-psim)[:, nz])/id[:, nz]
+        nz = np.any(iq != 0., axis=1)
+        lq = (psiq2[nz, :])/iq[nz, :]
+
+        # create interpolation functions
+        return (ip.RectBivariateSpline(iq[:, 0], id[0][id[0] != 0], ld),
+                ip.RectBivariateSpline(iq[:, 0][iq[:, 0] != 0], id[0], lq),
+                ip.RectBivariateSpline(iq[:, 0], id[0], psim))
+
 
     ### EXPERIMENTAL
 
     def transient(self, u1, tload, speed,
                   fault_type=3, # 'LLL', 'LL', 'LG',
-                  tend=0.1, nsamples=200):
-
-        tshort = 0
+                  tshort=0, tend=0.1, nsamples=200):
+        ns = round(tshort/tend*nsamples), round((tend-tshort)/tend*nsamples)
         w1 = 2*np.pi*self.p*speed
+        i0 = self.iqd_torque(tload)
         res = so.minimize(
-            lambda iqd: np.linalg.norm(iqd), self.io, method='SLSQP',
+            np.linalg.norm, i0, method='SLSQP',
             constraints=(
-                {'type': 'eq',
+                {'type': 'ineq',
                  'fun': lambda iqd: self.tmech_iqd(*iqd, speed) - tload},
                 {'type': 'ineq',
                  'fun': lambda iqd: np.sqrt(2)*u1
                  - la.norm(self.uqd(w1, *iqd))}))
         iqx, idx = res.x
         uq0, ud0 = self.uqd(w1, iqx, idx)
+        psid = ip.RectBivariateSpline(self.iq, self.id, self.psid, kx=3, ky=3)
+        psiq = ip.RectBivariateSpline(self.iq, self.id, self.psiq, kx=3, ky=3)
         logger.info("transient: Torque %f Nm, Speed %f rpm, Curr %f A",
                     tload, speed*60, betai1(iqx, idx)[1])
+        #_ld, _lq, _psim = self.ldlqpsim()
+        #Ld = _ld(iqx, idx)[0, 0]
+        #Lq = _lq(iqx, idx)[0, 0]
+        #psim = _psim(iqx, idx)[0, 0]
+        #logger.info("idx %f iqx %f, Ld %f, Lq %f, psim %f",
+        #            idx, iqx, Ld, Lq, psim)
         if fault_type == 3:  # 3 phase short circuit
-            USC = lambda t: np.zeros(2)
+            Y0 = iqx, idx
+            def U(t):
+                return (uq0, ud0) if t < tshort else (0, 0)
+            def didt(t, iqd):
+                uq, ud = U(t)
+                ldd = psid(*iqd, dx=0, dy=1)[0,0]
+                lqq = psiq(*iqd, dx=1, dy=0)[0,0]
+                ldq = psid(*iqd, dx=1, dy=0)[0,0]
+                lqd = psiq(*iqd, dx=0, dy=1)[0,0]
+                psi = psid(*iqd)[0,0], psiq(*iqd)[0,0]
+                return [
+                    (-ldd*psi[0]*w1 + ldd*(uq-self.r1*iqd[0])
+                     - lqd*psi[1]*w1 - lqd*(ud-self.r1*iqd[1]))/(ldd*lqq - ldq*lqd),
+                    (ldq*psi[0]*w1 - ldq*(uq-self.r1*iqd[0])
+                     + lqq*psi[1]*w1 + lqq*(ud-self.r1*iqd[1]))/(ldd*lqq - ldq*lqd)]
+            #def didtl(t, iqd):
+            #    lqd = lq(*iqd)[0,0], ld(*iqd)[0,0]
+            #    return [
+            #        (uq-r1*iqd[0] -w1 * ld*iqd[1] - w1*psim(*iqd)[0,0])/lq,
+            #        (ud-r1*iqd[1] +w1 * lq*iqd[0])/ld]
         else: # 2 phase short circuit
-            #ustat = np.array([K(w1*x).dot((uq, ud)) for x in t])
-            USC = lambda t: np.array([
-                uq0/2*(1+np.cos(2*w1*t)),
-                uq0/2*np.sin(2*w1*t)])
-        U = lambda t: (uq0, ud0) if t < tshort else USC(t)
-
-        psid = ip.RectBivariateSpline(self.iq, self.id, self.psid, kx=3, ky=3)
-        psiq = ip.RectBivariateSpline(self.iq, self.id, self.psiq, kx=3, ky=3)
-        #ld = ip.RectBivariateSpline(iq, id, dqpars['psidq'][0]['ld'], kx=3, ky=3)
-        #lq = ip.RectBivariateSpline(iq, id, dqpars['psidq'][0]['lq'], kx=3, ky=3)
-        #psim = ip.RectBivariateSpline(iq, id, dqpars['psidq'][0]['psim'], kx=3, ky=3)
-        #def didtl(t, iqd):
-        #    lqd = lq(*iqd)[0,0], ld(*iqd)[0,0]
-        #    return [
-        #        (uq-r1*iqd[0] -w1 * lqd[1]*iqd[1] - w1*psim(*iqd)[0,0])/lqd[0],
-        #        (ud-r1*iqd[1] +w1*lqd[0]*iqd[0])/lqd[1]]
-
-        def didt(t, iqd):
-            uq, ud = U(t)
-            ldd = psid(*iqd, dx=0, dy=1)[0,0]
-            lqq = psiq(*iqd, dx=1, dy=0)[0,0]
-            ldq = psid(*iqd, dx=1, dy=0)[0,0]
-            lqd = psiq(*iqd, dx=0, dy=1)[0,0]
-            psi = psid(*iqd)[0,0], psiq(*iqd)[0,0]
-            return [
-                (-ldd*psi[0]*w1 + ldd*(uq-self.r1*iqd[0])
-                 - lqd*psi[1]*w1 - lqd*(ud-self.r1*iqd[1]))/(ldd*lqq - ldq*lqd),
-                (ldq*psi[0]*w1 - ldq*(uq-self.r1*iqd[0])
-                 + lqq*psi[1]*w1 + lqq*(ud-self.r1*iqd[1]))/(ldd*lqq - ldq*lqd)]
-
-        t = np.linspace(0, tend, nsamples)
-        Y0 = iqx, idx
+            _ld, _lq, _psim = self.ldlqpsim()
+            Ld = _ld(iqx, idx)[0, 0]
+            Lq = _lq(iqx, idx)[0, 0]
+            psim = _psim(iqx, idx)[0, 0]
+            Y0 = (0,)
+            def didt(t, i):
+                gamma = w1*t
+                iqd = [2/3*i*(-np.sin(gamma) + np.sin(gamma+2*np.pi/3)),
+                       2/3*i*(np.cos(gamma) + np.cos(gamma+2*np.pi/3))]
+                ldd = psid(*iqd, dx=0, dy=1)[0,0]
+                lqq = psiq(*iqd, dx=1, dy=0)[0,0]
+                ldq = psid(*iqd, dx=1, dy=0)[0,0]
+                lqd = psiq(*iqd, dx=0, dy=1)[0,0]
+                psi = psid(*iqd)[0, 0], psiq(*iqd)[0, 0]
+                A = ((ldd-lqq)*np.cos(2*gamma + np.pi/3)
+                     - (ldq+lqd)*np.sin(2*gamma + np.pi/3) + lqq + ldd)
+                B = 2/3*w1*((ldd-lqq)*np.sin(2*gamma + np.pi/3)
+                            + (ldq+lqd)*np.cos(2*gamma + np.pi/3)
+                            + ldq - lqd) + 2*self.r1
+                C = np.sqrt(3)*w1*(psi[0]*np.sin(gamma + np.pi/6)
+                                   + psi[1]*np.cos(gamma + np.pi/6))
+                return -(B*i + C)/A
+
+            #def didt2(t, i):
+            #    gamma = w1*t
+                # idy, iqy = T(gamma).dot([i[0], -i[0], 0])
+                # ua - ub = 0; ia = -ib; ic = 0
+            #    B = np.sqrt(3)*psim*np.cos(gamma + np.pi/6)
+            #    A = 2*Ld*np.cos(gamma + np.pi/6)**2 + 2*Lq*np.sin(gamma + np.pi/6)**2
+            #    dAdt = 4*w1*np.cos(gamma+np.pi/6)*np.sin(gamma+np.pi/6)*(Ld - Lq)
+            #    dBdt = np.sqrt(3)*w1*psim*np.sin(gamma+np.pi/6)
+
+            #    return -(i*dAdt + dBdt + 2*self.r1*i)/A
+
+        t = np.linspace(tshort, tend, ns[1])
         sol = ig.solve_ivp(didt, (t[0], t[-1]), Y0, dense_output=True)
         y = sol.sol(t).T
 
+        t = np.linspace(0, tend, nsamples)
+        if fault_type == 3:  # 3 phase short circuit
+            if ns[0] > 0:
+                iqd = np.vstack(
+                    (np.ones((ns[0], 2)) * (iqx, idx), y))
+            else:
+                iqd = y
+            iabc = np.array([K(w1*x[0]).dot((x[1][1], x[1][0]))
+                             for x in zip(t, iqd)]).T
+            peaks, valleys = find_peaks_and_valleys(t, iabc, tshort)
+
+            #iqx, idx = iqd[-1, 0], iqd[-1, 1],
+            #Ld = _ld(iqx, idx)[0, 0]
+            #Lq = _lq(iqx, idx)[0, 0]
+            #psim = _psim(iqx, idx)[0, 0]
+            #logger.info("idx %f iqx %f, Ld %f, Lq %f, psim %f",
+            #            idx, iqx, Ld, Lq, psim)
+            return {
+                't': t.tolist(),
+                'iq': iqd[:,0], 'id': iqd[:,1],
+                'istat': iabc.tolist(),
+                'peaks': peaks,
+                'valleys': valleys,
+                'torque': [self.torque_iqd(*x) for x in iqd]}
+        if ns[0] > 0:
+            iabc = np.hstack(
+                (np.array(
+                    [K(w1*t).dot((idx, iqx))
+                     for t in np.linspace(0, tshort, ns[0])]).T,
+                 [y[:, 0], (-y)[:, 0], np.zeros(ns[1])]))
+        else:
+            iabc = np.array(
+                 [y[:, 0], (-y)[:, 0], np.zeros(len(t))])
+        peaks, valleys = find_peaks_and_valleys(t, iabc, tshort)
+        idq = np.array([T(w1*x[0]).dot(x[1])
+                        for x in zip(t, iabc.T)]).T
         return {
             't': t.tolist(),
-            'iq': y[:,0], 'id': y[:,1],
-            'istat': np.array([K(w1*x[0]).dot((x[1][1], x[1][0]))
-                               for x in zip(t, y)]).T.tolist(),
-            'torque': [self.torque_iqd(*iqd) for iqd in y]}
+            'iq': idq[1], 'id': idq[0],
+            'istat': iabc.tolist(),
+            'peaks': peaks,
+            'valleys': valleys,
+            'torque': self.torque_iqd(idq[1], idq[0])}

femagtools/machine/utils.py

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 
 def K(d):
     """space phasor transformation matrix
-    (Inverse Park Transformation) T-1 * dq
+    (Inverse Park Transformation) T-1 * dq --> abc
     arguments:
       d: rotation angle
 
@@ -28,7 +28,7 @@ def K(d):
 
 def T(d):
     """space phasor transformation matrix
-    (Park Transformation) T * abc
+    (Park Transformation) T * abc --> dq
     arguments:
       d: rotation angle
 

femagtools/plot/bch.py

@@ -508,19 +508,33 @@ def transientsc(bch, title=''):
     row = 1
     plt.subplot(rows, cols, row)
     ax = plt.gca()
-    ax.set_title('Currents / A')
     ax.grid(True)
-    for i in ('ia', 'ib', 'ic'):
-        ax.plot(bch.scData['time'], bch.scData[i], label=i)
+    istat = np.array([bch.scData[i]
+                      for i in ('ia', 'ib', 'ic')])
+    if np.max(istat) > 4000:
+        istat *= 1e-3
+        ax.set_title('Currents / kA')
+    else:
+        ax.set_title('Currents / A')
+
+    for i, iph in zip(('ia', 'ib', 'ic'), istat):
+        ax.plot(bch.scData['time'], iph, label=i)
     ax.set_xlabel('Time / s')
     ax.legend()
 
     row = 2
     plt.subplot(rows, cols, row)
     ax = plt.gca()
-    ax.set_title('Torque / Nm')
+    scale = 1
+    torque = np.array(bch.scData['torque'])
+    if np.max(torque) > 4000:
+        torque *= 1e-3
+        ax.set_title('Torque / kNm')
+    else:
+        ax.set_title('Torque / Nm')
+
     ax.grid(True)
-    ax.plot(bch.scData['time'], bch.scData['torque'])
+    ax.plot(bch.scData['time'], torque)
     ax.set_xlabel('Time / s')
 
     fig.tight_layout(h_pad=2)

femagtools/templates/mesh-airgap.mako

@@ -14,13 +14,22 @@ if not airgap_created then
     end
 % if hasattr(model, 'bore_diam'):
     r1 = m.fc_radius - ag/6
+    if(m.npols_gen == m.num_poles) then
+      alfa = alfa / 2
+    end
     x1, y1 = pr2c(r1, alfa)
     n = math.floor(m.fc_radius*alfa/agndst + 1.5)
     nc_circle_m(r1, 0, x1, y1, 0.0, 0.0, n)
+    if(m.npols_gen == m.num_poles) then
+       nc_circle_m(x1, y1, r1, 0, 0.0, 0.0, n)
+    end
 
     r2 = m.fc_radius + ag/6
     x2, y2 = pr2c(r2, alfa)
     nc_circle_m(r2, 0, x2, y2, 0.0, 0.0, n)
+    if(m.npols_gen == m.num_poles) then
+       nc_circle_m(x2, y2, r2, 0, 0.0, 0.0, n)
+    end
 
     if inner_da_start == nil then
       inner_da_start = da2/2

femagtools/templates/statorRotor3.mako

@@ -34,6 +34,9 @@ m.slot_top_sh = ${model['slot_top_sh']}
 m.zeroangl    = ${model.get('zeroangle',0)}
 m.rlength     = ${model.get('rlength',1)*100}
 
+% if model.get('ac_loss', False):
+  m.ac_loss = ${model.get('ac_loss', 3)}
+% endif
 m.mcvkey_yoke = mcvkey_yoke
 
 pre_models("STATOR_3")

{femagtools-1.7.4.dist-info → femagtools-1.7.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: femagtools
-Version: 1.7.4
+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.4.dist-info → femagtools-1.7.6.dist-info}/RECORD

@@ -1,9 +1,9 @@
-femagtools/__init__.py,sha256=LQSh6OjWbECaFlDSZXzy-njc7_TUylPuMfvbQVJYH9I,1600
+femagtools/__init__.py,sha256=bsP3-dUn57w5F0J2342CXVQfsk2pVYuVby-g3MuoFjM,1600
 femagtools/airgap.py,sha256=hELJXe52yUw82JwZ1tGUXUtRhMG2_WSUBVeGkTZSAM8,1900
 femagtools/amazon.py,sha256=O1ICuv21XDAJi1qK1Sigs2TdS6hDZP19OzvmE2t76wU,12069
 femagtools/amela.py,sha256=pHjfXzpANI-7oz8MtrqNcyDZ6PxVM91vCJuvYhHy1rk,13891
 femagtools/asm.py,sha256=CiL0KWaF4P7O6-VwmGLdva_icwmPrPiI-TFQ19XYTKk,7660
-femagtools/bch.py,sha256=aWTOQ8Hq2ygLPQpf5k9W0nWUPK0UXe0YewArrPI7IBk,73550
+femagtools/bch.py,sha256=FYpQsbCaJB6GJHwUto4aCq94Yz1DtYAbaj7l-gGjmY4,73716
 femagtools/bchxml.py,sha256=KrRjAdrUPZXmiWvonu9HhpG_NvImMBpiXWTL4iSr4kE,3142
 femagtools/condor.py,sha256=J8z9iBdvrGu3I1eFNoyKV8AXzRoTEPGLSak6cXUQxAM,10766
 femagtools/conductor.py,sha256=rXO7c7Qh_s7JpgILmLd4IbG64vP6Eh143YF9u25Mdwg,1076
@@ -17,7 +17,7 @@ femagtools/ecloss.py,sha256=gaZ8JmlFVoP6IYe79YXPXvZSULm8IZr6bPBdKuyKaIo,12832
 femagtools/erg.py,sha256=IXKq76P9qLt_ssNOP78v8Qizk3J2Zg80yaKDSjzwoJE,1224
 femagtools/femag.py,sha256=RUkjvkHe5gBElawh4-cbwueplXA5Tjvnu28CPVw6f74,44123
 femagtools/forcedens.py,sha256=7NNv75Vg9vQ_fy8W4kM2rlSO970zaSmeurhPmdAxsOU,8485
-femagtools/fsl.py,sha256=htSzZkguxDsVvIBXi6VK3YRqUbYAlQ_R4jLRfcOmIzw,33872
+femagtools/fsl.py,sha256=wlQkaFslVhbhLYuFJMddlOAOjWoZfeQgBUi6zNS4s-A,33977
 femagtools/getset.py,sha256=yJ6Em35DeWK7WNZW0qjjS5s7LUkVh5mbgxF59HHm5FM,3017
 femagtools/gmsh.py,sha256=IKhNiviIBji4cMxAhxaYXNqBRMNAPSKsBGdnGyxkyQw,3903
 femagtools/google.py,sha256=ugRyHY1zBjHR4aNfbA7GeF-ZU_NgleuVTZaWpi_XLT4,17144
@@ -48,20 +48,20 @@ femagtools/vbf.py,sha256=9XGfhftmD9carU8ByQ5DwqoR4daq5mJ39eMqruwml0Q,2444
 femagtools/vtu.py,sha256=Sf83dHIfCKY2km-MIUHKKoj-JKN4PDX7kkPLZXyIYY4,10723
 femagtools/windings.py,sha256=-PDqzatXJUaMTR4hI1bbY__AAb3fjwfjiS9FEuR-8N8,22305
 femagtools/dxfsl/__init__.py,sha256=MywcCdpKPKs4qJBJJgeDsikJFJ2P48dbTuNk303f5pM,76
-femagtools/dxfsl/area.py,sha256=cYnDtnEuwuDW5R1NKV0s8PUzzQzxhgCUktFqHAjP9K8,56581
+femagtools/dxfsl/area.py,sha256=Y7qNteasOB54hzo-QkDlHdjcym74FKJVdUrKaCFy23I,60813
 femagtools/dxfsl/areabuilder.py,sha256=Siu11yRcNJiSCWwc865-OvuVhSmLtRQWysbe1-rUcN0,34197
 femagtools/dxfsl/concat.py,sha256=F6scwesxyOmfmKQ5kGspNCxA71Yz6QgxFL7lTj3hsaI,13385
-femagtools/dxfsl/conv.py,sha256=GeRYUvbdcP5vKtNm5S5gU1yyMboGkGNyOqzkHpYbEEo,10086
-femagtools/dxfsl/converter.py,sha256=BRIzgg15gqnO-FJ6maVJ1YI3i-elY6Dwbs_-dNTiL94,32412
+femagtools/dxfsl/conv.py,sha256=Z_jf4OTxikr-SoUuBew_wrEj32qcGPyEp7VMtkRJx9M,10747
+femagtools/dxfsl/converter.py,sha256=txsDdMbQxMLXyAC5LV97ZifO49O5oXu-SRM1wqawSUs,33223
 femagtools/dxfsl/corner.py,sha256=-XPBcnEau-2-SRHLYzlBqCQGaFfgm_DH2qR1mSaFoAs,1311
 femagtools/dxfsl/dumprenderer.py,sha256=n4AvInjvGIaC2iKZtQaYXXDyJVSQ3uEOFOLD4-xfKRY,1861
 femagtools/dxfsl/dxfparser.py,sha256=kyXG0kZfNyOgn96MqBgP8RhOQhppfB5NbyRNNybs1C0,13451
 femagtools/dxfsl/femparser.py,sha256=O8940Q1Mz8MKng6W8M3s9KfTvhDLJ56tfQWtZEW3xMM,2134
-femagtools/dxfsl/fslrenderer.py,sha256=PBy3KUlNIqItcxCFnWC-d3OrSrsNFj5vDLLGZW2oq3Q,25081
+femagtools/dxfsl/fslrenderer.py,sha256=6mwQv9D45dgR2rmBovcediwfGEnmLGDAWaIfUo2Qd1o,25257
 femagtools/dxfsl/functions.py,sha256=F0AjzHfIfq3v-mhDzUOeq3zeYQCEsJl1-XpEyJQsSnQ,11805
-femagtools/dxfsl/geom.py,sha256=-hPErBLyAsDh-aq2s54psFqG2AaNr9jVeKMeEVUQF5E,165356
+femagtools/dxfsl/geom.py,sha256=lHmhuDNNM30fTT6p3-cOBkOUI5MKE6PnQ_ShEYDpm58,169937
 femagtools/dxfsl/journal.py,sha256=S17B7wsrq5QzIUbjgg0ntvnpgH0thHq9aQXO7GdYlQQ,4265
-femagtools/dxfsl/machine.py,sha256=3leWkjdMCLX2HgMhw8gNdxTKROhNCKU7KQrDVbBQ8DI,49337
+femagtools/dxfsl/machine.py,sha256=mMi6_eL4b5aZMF67jUS3bXZyr2RorcV9qfJEntejxUk,50098
 femagtools/dxfsl/plotrenderer.py,sha256=q2cORuxJEf1Ws6oCY9c0gF6N3kDrcI6WOz3u5Vl6R_c,13823
 femagtools/dxfsl/shape.py,sha256=ZmWw7VTSJs5rcY1Lh99MKo804mO7dSGHdKMIh-nVBow,59904
 femagtools/dxfsl/svgparser.py,sha256=R8V2V5jE6JyVfzshJVaPgsSuMlQf_pwJTFvrTrKDxZ0,2905
@@ -70,10 +70,10 @@ femagtools/machine/__init__.py,sha256=U8W65K7jr7jDdC1KnJh0WjYd8DFaLnIFVvlh-TKcV9
 femagtools/machine/afpm.py,sha256=hNyDFRLGmCuWRPZl_u1ztJ4pA-Y_mxLaVvg3UJkzRuE,24766
 femagtools/machine/effloss.py,sha256=sLB8AXYVAE_AL1Ca41A2EDbn9_7u6xNjaYFjmRPoTDg,13578
 femagtools/machine/im.py,sha256=3Y54AHMZfAjkvgexx2E-5jxNWzaVQ-SyaETCh7gNBYA,38008
-femagtools/machine/pm.py,sha256=4gqYLWACE7C9FzmiHVwh6M2WT7ofNezEIazkAxLae8Q,61704
+femagtools/machine/pm.py,sha256=IfKQPyrVc2AV78rWy2bW1GB1SvM6Ro-XHhOU7RT95Dk,67677
 femagtools/machine/sizing.py,sha256=nWCfxbyWfbw5-7xu0qZ6zjWNquEPn3fUH-fQeGb6QUc,24307
 femagtools/machine/sm.py,sha256=G4fHmZngQSRN9Dum7mHaf36b_CvD-u_AQogIFixlnys,37899
-femagtools/machine/utils.py,sha256=zi659wCszhXEioKXtRdeyQik2etRFGpoykqfOGiLtTo,21223
+femagtools/machine/utils.py,sha256=lDbOP4HisdOa7Wi-8xLB1jPvwyM_51SFc-xyJYIz4Eo,21238
 femagtools/moo/__init__.py,sha256=zinmWEOrsEz6DmMX0Dbn4t6_1UR-p4bEGqyR1wUQk_Q,175
 femagtools/moo/algorithm.py,sha256=lNEf0Bur4yFpIJeLtAC3oIus8sOMWTb7jepFlD28YzE,5445
 femagtools/moo/population.py,sha256=qGEsm-2Ys_pTkVQv3Zv36HzOlqUxtMvM6NqY_KytsUE,10060
@@ -82,7 +82,7 @@ femagtools/moo/test/AlgorithmTest.py,sha256=KzR1og4bu6NOE61DDKjEMTQdsysmho4LCYmJ
 femagtools/moo/test/PopulationTest.py,sha256=lG9NeWo0xrslfQRa4tgy1Nj23VJMFIlg_vQ9KUBYnRA,5529
 femagtools/moo/test/ProblemTest.py,sha256=r5XEfY4LPscDb35TxxPd0lbP3nUmL6_G6vrRo1I3RSg,505
 femagtools/plot/__init__.py,sha256=dD_wvo6sGc8jvJYD1b0Z7oxCE4O9uQ3Igb5DeAjZDWU,939
-femagtools/plot/bch.py,sha256=4f9Q-JZtj9WMjxFUXMXNaSdWdDXN_Be4-F9kOU45xns,28525
+femagtools/plot/bch.py,sha256=_EEPPEqtEPeWco3xlQqUuZft1eF-IXbMNnXyd8pYEJs,28873
 femagtools/plot/char.py,sha256=iDvrKp_Hz10W7qLjWCtYajKjY01fZbwf_kITDGisPaY,12123
 femagtools/plot/fieldlines.py,sha256=QtKF4nhnQ_FHHGh9Qez3GVmym0CLhW1ZyIKtk4pzos4,1136
 femagtools/plot/fluxdens.py,sha256=NlexRJ3f_8CgKoWrV82ZIsAXPrLhwj98uOe8_fUks7A,1082
@@ -129,7 +129,7 @@ femagtools/templates/magnetSector.mako,sha256=db_i1jNJ4TONkBIEKVIWVRZkEJWPwO_r4M
 femagtools/templates/magnetSectorLinear.mako,sha256=ez2rkZslw66Zy4DCDiLjI2K45nEjGgunl0jsXseO_Zs,727
 femagtools/templates/magnetShell.mako,sha256=vpyZIZ5tOsrmUVM00Kime7zyu1lK9P61xq78jB8BLdo,1295
 femagtools/templates/magnetShell2.mako,sha256=4IJBfBTPxuYHr1SAcVvNdQoGd8emwsx8vMKQPI9pRlc,4080
-femagtools/templates/mesh-airgap.mako,sha256=QFutdFUnz5lMpjRT9cN0w6EPShccYJfz4yuMqNYoZ1Y,3425
+femagtools/templates/mesh-airgap.mako,sha256=9fESevBQJSIf0uCWJIRqhZaj-2-HEjR3nJl-YfKebPo,3685
 femagtools/templates/modal_analysis.mako,sha256=Thf62FBqL738qnp1ongPr196GJY27vwElKqPfMWF45s,2298
 femagtools/templates/modified_steinmetz.mako,sha256=qrJ18XtoU39kjbcdywCJCLObQGaO-eC3Cl-1P4xLZWg,1327
 femagtools/templates/mult_cal_fast.mako,sha256=FhqRZQaBIIvmx0LgKXVLOIjz7LshoDFHqhkD0QGlX8A,1255
@@ -157,7 +157,7 @@ femagtools/templates/stator3Linear.mako,sha256=pNe3C1wT0W2C0qePo3sEyebW1z_dpTuJz
 femagtools/templates/stator4.mako,sha256=Jq8pfIuOmmpyGOL1z2aQZfbwMS5-Zyn6OGJ51LCBVKs,1179
 femagtools/templates/statorBG.mako,sha256=fh0cVOZVWyLojlGxWJoFz2pvdL6Yxy4xzhY-Joc2xeg,893
 femagtools/templates/statorRing.mako,sha256=sDgDmk71EoE8d4e9cmyqKqRldfC8uKMmpHEjXJGIt_k,2071
-femagtools/templates/statorRotor3.mako,sha256=MrU_JCSH8tJEUH09fftJJslkbEeIwOB1WGBSxXqUqeI,4942
+femagtools/templates/statorRotor3.mako,sha256=6NTmHKetgsfi4tsN_OSNqZ08y_KVXLOMs7VkeN6Bngk,5025
 femagtools/templates/stator_msh.mako,sha256=Neze1ielMCk7TrARyhOra91fFQVT8Phsgk2Omt_aMG8,1799
 femagtools/templates/therm-dynamic.mako,sha256=pEz7jrUpopK1-RqgulNnrkSaCZDjfLelsVo6cBqmpac,3142
 femagtools/templates/therm_static.mako,sha256=ulevp4AP-kZ1_qdScPMaX9tLqvvP0t9lFflWTXgUxaE,1310
@@ -212,9 +212,9 @@ tests/moo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/moo/test_algorithm.py,sha256=Em8sFm2vzPmuIzRrBBnUQLU_TYuJHSf-kEeozw0XeX4,2563
 tests/moo/test_population.py,sha256=FvX9LRCxQx0_E2GxHQ5vKwOYFBQiNbT6Lmv5GmNWjTQ,5471
 tests/moo/test_problem.py,sha256=ALeP4u7g-dFhfwWL8vxivdrrYzVKPjHMCAXzzgyNZbs,467
-femagtools-1.7.4.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
-femagtools-1.7.4.dist-info/METADATA,sha256=mDq3sIVGX9_9OYQa4NObTZud2BH92rKQUJe7GR9bZNM,6156
-femagtools-1.7.4.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-femagtools-1.7.4.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
-femagtools-1.7.4.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.7.4.dist-info/RECORD,,
+femagtools-1.7.6.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
+femagtools-1.7.6.dist-info/METADATA,sha256=dTUdOh7eh4dgbkfeUTUDK1OPxGSMniFY3sSxQNl_BGg,6156
+femagtools-1.7.6.dist-info/WHEEL,sha256=cVxcB9AmuTcXqmwrtPhNK88dr7IR_b6qagTj0UvIEbY,91
+femagtools-1.7.6.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
+femagtools-1.7.6.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
+femagtools-1.7.6.dist-info/RECORD,,

{femagtools-1.7.4.dist-info → femagtools-1.7.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (72.1.0)
+Generator: setuptools (74.1.2)
 Root-Is-Purelib: true
 Tag: py3-none-any