femagtools 1.8.18__py3-none-any.whl → 1.8.19__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.18'
+__version__ = '1.8.19'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2025 Gamma Technology'

femagtools/bch.py

@@ -271,7 +271,7 @@ class Reader:
             return self.flux[0]['displ'][1]-self.flux[0]['displ'][0]
         return None
 
-    def read(self, content):
+    def read(self, content, **kwargs):
         """read bch file
 
         Args:
@@ -297,7 +297,10 @@ class Reader:
                     if k == title2[:len(k)]:
                         title = title2[:len(k)]
             if title in self.dispatch:
-                self.dispatch[title](self, s)
+                if title == 'Airgap Induction Br':
+                    self.dispatch[title](self, s, kwargs.get('ignore_airgap_induction_with_c_step_section', True))
+                else:
+                    self.dispatch[title](self, s)
 
         if len(self.weights) > 0:
             w = list(zip(*self.weights))
@@ -887,7 +890,7 @@ class Reader:
             self.flux_fft[self.wdg] = []
         self.flux_fft[self.wdg].append(flux_fft)
 
-    def __read_airgapInduction(self, content):
+    def __read_airgapInduction(self, content, ignore_c_step_section=True):
         "read and append airgapInduction section"
         import scipy.integrate as si
         import math
@@ -918,7 +921,9 @@ class Reader:
                 i1beta = True
                 continue
             if line.startswith("C_STEP"):
-                return   # ignore this section
+                if ignore_c_step_section:
+                    return  # ignore this section
+                continue
             try:
                 rec = self.__findNums(line)
                 if len(rec) == 10:
@@ -966,6 +971,10 @@ class Reader:
             self.airgapInduction['iq'] = iq
             self.airgapInduction['id'] = id
             nrows = len(self.airgapInduction['id'])
+        if not ignore_c_step_section:
+            # min 1 required (section with C_STEP)
+            nrows = max(1, nrows)
+            ncols = max(1, ncols)
 
         try:
             self.airgapInduction['an'] = [np.reshape(an[j][:nrows*ncols],
@@ -999,6 +1008,14 @@ class Reader:
                                                      [1:])
                     self.airgapInduction['Bm'] = zip(*zip(*self.airgapInduction['Bm'])
                                                      [1:])
+            elif not ignore_c_step_section:
+                # section with C_STEP and a single data linex
+                self.airgapInduction['an'] = [self.airgapInduction['an'][i][0:]
+                                              for i in range(4)]
+                self.airgapInduction['bn'] = [self.airgapInduction['bn'][i][0:]
+                                              for i in range(4)]
+                self.airgapInduction['Ba'] = self.airgapInduction['Ba'][0:]
+                self.airgapInduction['Bm'] = self.airgapInduction['Bm'][0:]
         except ValueError:
             print(self.airgapInduction['i1'])
 
@@ -1858,12 +1875,12 @@ class Reader:
         return self.__str__()
 
 
-def read(filename):
+def read(filename, **kwargs):
     """Read BCH/BATCH results from file *filename*."""
     import io
     bchresults = Reader()
     with io.open(filename, encoding='latin1', errors='ignore') as f:
-        bchresults.read(f.readlines())
+        bchresults.read(f.readlines(), **kwargs)
     return bchresults
 
 

femagtools/dxfsl/area.py

@@ -1818,7 +1818,7 @@ class Area(object):
             logger.debug(">>> air is a circle")
             return self.type
 
-        self.set_close_to_start_end_angles(self, 0.0, alpha)
+        self.set_close_to_start_end_angles(0.0, alpha)
 
         if self.is_magnet_rectangle():
             self.type = TYPE_MAGNET_RECT  # magnet embedded

femagtools/dxfsl/areabuilder.py

@@ -16,7 +16,7 @@ from femagtools.dxfsl.area import Area, TYPE_AIR
 from femagtools.dxfsl.functions import points_are_close, nodes_are_equal, distance
 from femagtools.dxfsl.functions import normalise_angle, positive_angle, point
 from femagtools.dxfsl.functions import alpha_line, alpha_points, alpha_angle
-from femagtools.dxfsl.functions import less, is_same_angle
+from femagtools.dxfsl.functions import less, less_equal, greater, is_same_angle
 from femagtools.dxfsl.functions import Timer
 from femagtools.dxfsl.journal import getJournal
 import io
@@ -135,7 +135,7 @@ class EdgeInfo(object):
         self.angle = positive_angle(alpha_angle(start_angle, self.n1_angle_ingoing()))
         logger.debug("set_direction_angle: angle is %s", self.angle)
 
-        if is_same_angle(0.0, self.angle, atol=0.008):  # 1/2 degree
+        if is_same_angle(0.0, self.angle, atol=0.015):  # 1/2 degree
             # reverse direction
             logger.debug("set_direction_angle: reverse direction( nearly 180 degrees)")
 
@@ -218,7 +218,7 @@ class EdgeInfo(object):
         myself_angle = self.angle
         other_angle = nbr_edge.angle
 
-        if is_same_angle(0.0, myself_angle):
+        if is_same_angle(0.0, myself_angle, atol=0.015):
             # 360 or 0 degrees => turn 180 degrees
             logger.debug("-- ATTENTION: myself %s turns nearly 180 degrees", self.classname())
             logger.debug("   the angle is %s", myself_angle)
@@ -261,7 +261,7 @@ class EdgeInfo(object):
                         logger.debug("#4: end of myself_direction_lefthand: ==> %s", left)
                         return left
 
-        if is_same_angle(0.0, other_angle, atol=0.008):  # 1/2 degree
+        if is_same_angle(0.0, other_angle, atol=0.015):  # 1/2 degree
             # 360 or 0 degrees => turn 180 degrees
             logger.debug("-- ATTENTION: other %s turns nearly 180 degrees", nbr_edge.classname())
             logger.debug("   the angle is %s", other_angle)
@@ -288,7 +288,7 @@ class EdgeInfo(object):
 
         logger.debug("-- angles: myself = %s,  other = %s",
                      myself_angle, other_angle)
-        if not is_same_angle(myself_angle, other_angle, atol=0.008):  # 1/2 degree
+        if not is_same_angle(myself_angle, other_angle, atol=0.015):  # 1/2 degree
             logger.debug("-- angles are different")
             left = myself_angle > other_angle
             log_lefthand(left, self, nbr_edge)
@@ -778,7 +778,7 @@ class AreaBuilder(object):
         assert(self.geom.area_list)
         return self.get_lower_border_line()
 
-    def close_outer_winding_areas(self):
+    def close_outer_winding_areas(self, color='red'):
         logger.debug("begin close_outer_winding_areas")
 
         airgap_line, airgap_el = self.get_outer_airgap_line()
@@ -787,6 +787,15 @@ class AreaBuilder(object):
         if len(airgap_line) < 5:
             return False
 
+        distlist = [distance(self.geom.center, n) for n in airgap_line]
+        min_dist = min(distlist)
+        max_dist = max(distlist)
+        geom_height = self.geom.max_radius - self.geom.min_radius
+        line_height = max_dist - min_dist
+        if line_height < geom_height * 0.2:
+            return 0
+
+        logger.debug("NODES: %s TO %s", airgap_line[0], airgap_line[-1])
         n1 = None
         dist_n1 = 0.0
 
@@ -795,22 +804,29 @@ class AreaBuilder(object):
         dist_prev = distance(self.geom.center, n_prev)
         alpha_prev = alpha_line(self.geom.center, n_prev)
         alpha_start = alpha_prev
-
         lines_created = 0
+        dist_ag = self.geom.min_radius
+        logger.debug("MIN RADIUS DIST: %s",dist_ag)
         for n in airgap_line[1:]:
             dist = distance(self.geom.center, n)
             alpha = alpha_line(self.geom.center, n)
+            logger.debug("Node %s, dist=%s, alpha=%s", n, dist, alpha)
             if not n1:
-                if dist > dist_prev and alpha < alpha_prev:
-                    n1 = n_prev
-                    dist_n1 = dist_prev
+                logger.debug("Previous, dist=%s, alpha=%s", dist_prev, alpha_prev)
+                if greater(dist_prev, dist_ag, rtol=1e-3, atol=1e-3):
+                    if greater(dist, dist_prev, rtol=1e-3, atol=1e-3) and \
+                       less(alpha, alpha_prev, rtol=1e-4, atol=1e-5):
+                        n1 = n_prev
+                        dist_n1 = dist_prev
+                        logger.debug("NODE1: %s  (%s)", n1, dist_n1)
             else:
-                if np.isclose(dist_n1, dist, rtol=1e-3, atol=1e-3):
+                if less_equal(dist, dist_n1, rtol=1e-3, atol=1e-2):
+                    logger.debug("NODE2: %s  (%s)", n, dist)
                     line = Line(Element(start=n1, end=n))
                     if e_prev.intersect_line(line):
                         logger.debug("___LINE NOT POSSIBLE___")
                     else:
-                        self.geom.add_line(n1, n, color='red')
+                        self.geom.add_line(n1, n, color=color)
                         lines_created += 1
                     n1 = None
                     dist_n1 = 0.0

femagtools/dxfsl/converter.py

@@ -286,6 +286,8 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
             machine_temp.create_mirror_lines_outside_windings()
     else:
         machine_temp = machine
+        if machine_temp.has_windings_in_the_middle():
+            machine_temp.create_mirror_lines_outside_windings()
 
     if machine_temp.geom.reduce_element_nodes(mindist):
         machine_temp.rebuild_subregions(EESM, single=single)

femagtools/dxfsl/fslrenderer.py

@@ -256,6 +256,9 @@ class FslRenderer(object):
                          'if mcvkey_yoke == nil then',
                          '  mcvkey_yoke = "dummy"',
                          '  ur = 1000.0',
+                         ' else if mcvkey_teeth == nil then',
+                         ' mcvkey_teeth = mcvkey_yoke',
+                         'end',
                          'end',
                          'x0_iron_tooth, y0_iron_tooth = 0.0, 0.0',
                          'x0_iron_yoke, y0_iron_yoke = 0.0, 0.0',

femagtools/dxfsl/geom.py

@@ -1182,7 +1182,7 @@ class Geometry(object):
             nx.set_edge_attributes(self.g, False, 1)
             nx.set_edge_attributes(self.g, False, 2)
 
-    def create_list_of_areas(self, main=False, delete=False):
+    def create_list_of_areas(self, main=False, delete=False, nolog=True):
         """ return list of areas for each node and their neighbors
         """
         if delete:  # clear list of areas
@@ -1193,7 +1193,7 @@ class Geometry(object):
             # list already available
             return
 
-        areabuilder = AreaBuilder(geom=self)
+        areabuilder = AreaBuilder(geom=self, nolog=nolog)
         areabuilder.create_list_of_areas(main=main)
         self.area_list = areabuilder.area_list
         logger.debug("area list created")
@@ -3337,6 +3337,31 @@ class Geometry(object):
         return [a for a in self.list_of_areas()
                 if a.is_type(type)]
 
+    def is_tooth(self, a, windings, wdg_min_dist, wdg_max_dist):
+        if a.around_windings(windings, self):
+            if a.close_to_ag:
+                return True
+            if self.is_inner:
+                if greater(a.min_dist, wdg_min_dist, atol=1e-1):
+                    return True
+            else:
+                if less(a.max_dist, wdg_max_dist, atol=1e-1):
+                    return True
+        return False
+
+    def between_airgap_and_winding(self, a,
+                                   wdg_min_angle,
+                                   wdg_max_angle,
+                                   wdg_min_dist,
+                                   wdg_max_dist):
+        if greater_equal(a.min_angle, wdg_min_angle) and \
+           less_equal(a.max_angle, wdg_max_angle):
+            if self.is_inner:
+                return less_equal(wdg_max_dist, a.min_dist)
+            else:
+                return less_equal(a.max_dist, wdg_min_dist)
+        return False
+
     def collect_windings(self):
         logger.debug("begin of collect_windings")
         good_windings = self.get_windings(AREA.TYPE_WINDINGS)
@@ -3409,7 +3434,7 @@ class Geometry(object):
             max_size, max_w = windings_surface[0]
             for sz, w in windings_surface[1:]:
                 logger.debug("winding size = %s", sz)
-                if sz / max_size < 0.70:
+                if sz / max_size < 0.60:
                     w.set_type(AREA.TYPE_AIR)
                     if sz / max_size < 0.2:
                         windings_found -= 1
@@ -3459,7 +3484,7 @@ class Geometry(object):
         air_areas = [a for a in self.list_of_areas()
                      if a.is_type(AREA.TYPE_AIR_OR_IRON)]
         for a in air_areas:
-            if a.around_windings(windings, self):
+            if a.around_windings(windings, self) and less(a.min_dist, wdg_max_dist - 0.5):
                 logger.debug("Area %s", a.identifier())
                 logger.debug(" - air-angle min/max = %s/%s",
                              a.min_air_angle,
@@ -3481,7 +3506,6 @@ class Geometry(object):
                            a.close_to_ag):
                             a.set_type(AREA.TYPE_AIR)  # air
                             continue
-
                         a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
                         continue
 
@@ -3510,14 +3534,28 @@ class Geometry(object):
                     a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
             else:
                 logger.debug("#5 not around windings")
-                a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
+                if self.between_airgap_and_winding(a,
+                                                   wdg_min_angle, wdg_max_angle,
+                                                   wdg_min_dist, wdg_max_dist):
+                    a.set_type(AREA.TYPE_AIR)  # air
+                else:
+                    if self.is_inner:
+                        if greater(a.min_dist, wdg_min_dist, atol=1e-1):
+                            a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
+                        else:
+                            a.set_type(AREA.TYPE_YOKE)  # iron shaft (Joch)
+                    else:
+                        if less(a.max_dist, wdg_max_dist, atol=1e-1):
+                            a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
+                        else:
+                            a.set_type(AREA.TYPE_YOKE)  # iron shaft (Joch)
 
         # yoke or shaft ?
         iron_areas = [a for a in self.list_of_areas()
                       if a.is_type(AREA.TYPE_YOKE)]
         for a in iron_areas:
             if a.around_windings(windings, self):
-                if less(a.min_dist, wdg_max_dist):
+                if less(a.min_dist, wdg_max_dist - 0.5):
                     if less_equal(a.max_dist, wdg_max_dist):
                         a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
                     else:
@@ -3922,6 +3960,15 @@ class Geometry(object):
             area.mark_airgap_corners(start_cp, end_cp)
         return
 
+    def get_areas_of_type(self, types=()):
+        return [area for area in self.list_of_areas()
+                if area.type in types]
+
+    def get_areas_of_irons(self):
+        return self.get_areas_of_type((AREA.TYPE_IRON,
+                                       AREA.TYPE_YOKE,
+                                       AREA.TYPE_TOOTH,))
+
     def num_areas_of_type(self, types=()):
         return len([area for area in self.list_of_areas()
                     if area.type in types])
@@ -4268,6 +4315,16 @@ class Geometry(object):
         for e in self.elements():
             e.adjust_points()
 
+    def split_with_point(self, p):
+        for e in self.elements(Shape):
+            elements = e.split([p])
+            if elements:
+                self.remove_edge(e)
+                for e in elements:
+                    self.add_element(e, rtol=self.rtol, atol=self.atol)
+                return True
+        return False
+
     def split_and_get_intersect_points(self, el, aktion=True, include_end=True):
         logger.debug("begin of split_and_get_intersect_points")
         rtol = 1e-03
@@ -4424,38 +4481,6 @@ class Geometry(object):
         builder = AreaBuilder(geom=self)
         return builder.create_inner_corner_auxiliary_areas(startangle, endangle)
 
-    def analyse_airgap_line(self, inner):
-        if inner:  # TODO
-            return False
-
-        areas = self.list_of_areas()
-        builder = AreaBuilder(geom=self)
-        ag_nodes, ag_el = builder.get_outer_airgap_line()
-        if not ag_nodes:
-            logger.warning("Fatal: No nodes found")
-            return False
-
-        distlist = [distance(self.center, n) for n in ag_nodes]
-        min_dist = min(distlist)
-        max_dist = max(distlist)
-        logger.debug("Airgap min/max from center: %s/%s", min_dist, max_dist)
-        for a in areas:
-            logger.debug("%s: min/max from center: %s/%s", a.identifier(), a.min_dist, a.max_dist)
-            logger.debug("%s: min/max x: %s/%s,  y:  %s/%s",
-                         a.identifier(),
-                         a.min_x, a.max_x,
-                         a.min_y, a.max_y)
-            if less_equal(a.min_x, -min_dist) and greater_equal(a.max_x, min_dist) and \
-               less_equal(a.min_y, -min_dist) and greater_equal(a.max_y, min_dist):
-                logger.debug("%s: around center", a.identifier())
-                continue
-            if np.isclose(a.min_dist, min_dist, rtol=1e-3, atol=1e-2):
-                continue
-            if less_equal(a.max_dist, max_dist, rtol=1e-3, atol=1e-2):
-                return False
-
-        return builder.close_outer_winding_areas()
-
     def adjust_outer_hull_for_symmetry(self):
         logger.debug("adjust_outer_hull_for_symmetry()")
         areas = self.list_of_areas()

femagtools/dxfsl/machine.py

@@ -646,7 +646,7 @@ class Machine(object):
                 self.geom.set_virtual_start_end_corners()
 
             self.geom.looking_for_corners()
-            create_areas = self.geom.analyse_airgap_line(is_inner)
+            create_areas = self.geom.close_outer_winding_areas()
             if self.geom.adjust_outer_hull_for_symmetry():
                 create_areas = True
 
@@ -1284,6 +1284,30 @@ class Machine(object):
     def search_critical_elements(self, mindist):
         self.geom.search_critical_elements(mindist)
 
+    def create_arc_element(self,
+                           radius,
+                           startangle,
+                           endangle):
+        arc = Arc(Element(center=self.center,
+                          radius=radius,
+                          start_angle=startangle*180/np.pi,
+                          end_angle=endangle*180/np.pi),
+                  color='darkred',
+                  linestyle='dotted')
+
+        node1 = self.geom.find_the_node(arc.p1)
+        if node1 is None:
+            self.geom.split_with_point(arc.p1)
+            node1 = self.geom.find_the_node(arc.p1)
+        node2 = self.geom.find_the_node(arc.p2)
+        if node2 is None:
+            self.geom.split_with_point(arc.p2)
+            node2 = self.geom.find_the_node(arc.p2)
+        assert(node1 is not None)
+        assert(node2 is not None)
+        logger.debug("ARC Node1=%s, Node2=%s", node1, node2)
+        self.geom.add_element(arc, rtol=1e-3, atol=1e-3)
+
     def create_arc(self, radius,
                    color='red', linestyle='dotted',
                    attr=None):
@@ -1344,6 +1368,79 @@ class Machine(object):
                                 self.endangle)
         return self.geom.possible_magnet_in_the_middle(midangle)
 
+    def separate_tooth_and_yoke(self, midangle):
+        logger.debug("begin separate_tooth_and_yoke")
+        wdg_list = self.geom.get_areas_of_type((AREA.TYPE_WINDINGS,))
+        wdg_max_dist = 0.0
+        wdg = None
+        for w in wdg_list:
+            if w.max_dist > wdg_max_dist:
+                wdg_max_dist = w.max_dist
+                wdg = w
+
+        tooth_list = self.geom.get_areas_of_type((AREA.TYPE_TOOTH,))
+        tooth_max_dist = 0.0
+        for tooth in tooth_list:
+            tooth_max_dist = max(tooth_max_dist, tooth.max_dist)
+        tooth_height = tooth_max_dist - self.geom.min_radius
+        wdg_height = wdg_max_dist - self.geom.min_radius
+
+        logger.debug("HEIGHT TOOTH=%s, WINDINGS=%s", tooth_height,  wdg_height)
+
+        if greater_equal(tooth_height, wdg_height * 0.9) and \
+           less_equal(tooth_height, wdg_height * 1.1):
+            logger.debug("Tooths are ok")
+            return False  # tooth ok
+
+        iron_list = self.geom.get_areas_of_irons()
+        tooth_list = [iron for iron in iron_list
+                      if iron.close_to_ag and greater(iron.max_dist, wdg_max_dist, rtol=1e-2, atol=1e-2)]
+        logger.debug("max winding dist = %s", wdg_max_dist)
+        logger.debug("tooths = %s", len(tooth_list))
+        wdg_nodes = [(distance(self.center, n), n) for n in wdg.list_of_nodes()]
+        wdg_nodes.sort(reverse=True)
+
+        top_nodes = []
+        other_nodes = []
+        for d, n in wdg_nodes:
+            if np.isclose(d, wdg.max_dist, rtol=1e-2, atol=1e-1):
+                top_nodes.append((alpha_line(self.center, n), d, n))
+            else:
+                other_nodes.append((d, alpha_line(self.center, n), n))
+
+        a_right, d_right, n_right = (None, None, None)
+        a_left, d_left, n_left = (None, None, None)
+
+        if not top_nodes:
+            other_nodes.sort(reverse=True)
+            for d, a, n in other_nodes:
+                if a > midangle:
+                    if not a_left:
+                        a_left = a
+                        d_left = d
+                        n_left = n
+                else:
+                    if not a_right:
+                        a_right = a
+                        d_right = d
+                        n_right = n
+                if a_left and a_right:
+                    break
+            if not (a_left and a_right):
+                logger.debug("end separate_tooth_and_yoke: no arcs possible")
+                return False # bad luck
+        else:
+            top_nodes.sort()
+            a_right, d_right, n_right = top_nodes[0]
+            a_left, d_left, n_left = top_nodes[0-1]
+        node_right = self.geom.find_the_node(n_right)
+        node_left = self.geom.find_the_node(n_left)
+
+        self.create_arc_element(d_right, self.startangle, a_right)
+        self.create_arc_element(d_left, a_left, self.endangle)
+        logger.debug("end separate_tooth_and_yoke")
+        return True
+
     def create_mirror_lines_outside_windings(self):
         logger.debug("create_mirror_lines_outside_windings")
 
@@ -1351,6 +1448,9 @@ class Machine(object):
             logger.debug("end create_mirror_lines_outside_windings: not done")
             return
 
+        midangle = middle_angle(self.startangle, self.endangle)
+        self.separate_tooth_and_yoke(midangle)
+
         radius = self.radius+10
         ag_list = self.geom.detect_airgaps(self.center,
                                            self.startangle, self.endangle,
@@ -1359,7 +1459,6 @@ class Machine(object):
         radius_list = [(ag[0], (ag[0] + ag[1]) / 2, ag[1]) for ag in ag_list]
         radius_list.sort(reverse=True)
 
-        midangle = middle_angle(self.startangle, self.endangle)
         line = Line(
             Element(start=self.center,
                     end=point(self.center, radius, midangle)))

femagtools/isa7.py

@@ -1359,28 +1359,31 @@ class Isa7(object):
         # prep dictionary for the loss calculation
         pm_data = []
         for i, se in enumerate(mag_spels):
-            ecp = [e.center for e in se.elements]
-            geometry = se.get_rect_geom()
-
-            #= np.moveaxis(bxy, 1, 0)
-            pd = dict(name='pm_data_se' + str(se.key),
-                      hm=geometry['h'],
-                      wm=geometry['w'],
-                      lm=self.arm_length,
-                      alpha=geometry['alpha'],
-                      ls=self.arm_length,
-                      sigma=cond,
-                      mur=mur,
-                      loadcase=ibeta,
-                      numpoles=poles,
-                      elcp=transform_coord(geometry, ecp),
-                      area=se.area(),
-                      spel_key=se.key)
-            if ibeta != None:
-                pd.update({'bl': self.get_magnet_flux_density(se, icur, ibeta)})
-            pd.update(pos)
-
-            pm_data.append(pd)
+            try:
+                ecp = [e.center for e in se.elements]
+                geometry = se.get_rect_geom()
+
+                #= np.moveaxis(bxy, 1, 0)
+                pd = dict(name='pm_data_se' + str(se.key),
+                          hm=geometry['h'],
+                          wm=geometry['w'],
+                          lm=self.arm_length,
+                          alpha=geometry['alpha'],
+                          ls=self.arm_length,
+                          sigma=cond,
+                          mur=mur,
+                          loadcase=ibeta,
+                          numpoles=poles,
+                          elcp=transform_coord(geometry, ecp),
+                          area=se.area(),
+                          spel_key=se.key)
+                if ibeta != None:
+                    pd.update({'bl': self.get_magnet_flux_density(se, icur, ibeta)})
+                pd.update(pos)
+
+                pm_data.append(pd)
+            except IndexError as e:
+                logger.warning("se %d magnet geometry ignored: %s", i, e)
         return pm_data
 
     def get_magnet_flux_density(self, se, icur, ibeta) -> list:

femagtools/machine/__init__.py

@@ -32,7 +32,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     PM, EESM or IM"""
     rlfe = lfe
     rwdg = wdg
-    opts = {k: eecpars[k] for k in ('zeta1', 'gam', 'kh', 'kpfe',
+    opts = {k: eecpars[k] for k in ('zeta1', 'gam', 'kh', 'kpfe', 'kpfe_s', 'kpfe_r',
                                     'kfric_b', 'kpmag') if k in eecpars}
     try:
         opts['rotor_mass'] = rlfe*eecpars['rotor_mass']
@@ -51,7 +51,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
             smpars = copy.deepcopy(eecpars)
             smpars['tcu1'] = temp[0]
             smpars['tcu2'] = temp[1]
-            # external inductances 
+            # external inductances
             opts["ls"] = eecpars.get('ls1', 0)*rwdg**2
             if 'ldq' in smpars:
                 machine = SynchronousMachineLdq(smpars, lfe=rlfe, wdg=rwdg, **opts)

femagtools/machine/effloss.py

@@ -372,6 +372,10 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     if isinstance(m, PmRelMachine):
         plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
         plfe2 = m.kpfe*m.iqd_plfe2(iqd[0], iqd[1], f1)
+        if hasattr(m, 'kpfe_s'):
+            plfe1 = m.kpfe_s*m.iqd_plfe1(*iqd, f1)
+        if hasattr(m, 'kpfe_r'):
+            plfe2 = m.kpfe_r*m.iqd_plfe2(iqd[0], iqd[1], f1)
         plmag = m.kpmag*m.iqd_plmag(iqd[0], iqd[1], f1)
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], 2*np.pi*f1)
         plcu2 = m.iqd_plcu2(*iqd)
@@ -385,6 +389,10 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     elif isinstance(m, SynchronousMachine):
         plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
         plfe2 = m.kpfe*m.iqd_plfe2(*iqd, f1)
+        if hasattr(m, 'kpfe_s'):
+            plfe1 = m.kpfe_s*m.iqd_plfe1(*iqd, f1)
+        if hasattr(m, 'kpfe_r'):
+            plfe2 = m.kpfe_r*m.iqd_plfe2(*iqd, f1)
         plmag = np.zeros_like(plfe2)
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], f1)
         try:

femagtools/machine/pm.py

@@ -97,7 +97,7 @@ class PmRelMachine(object):
         self.zeta1 = 0.2
         self.gam = 0.7
         self.kh = 2
-        self.kpfe = 1 # iron loss factor
+        self.kpfe = 1 # common iron loss factor
         self.kpmag = 1 # magnet loss factor
         self.kfric_b = 1
         self.rotor_mass = 0
@@ -258,7 +258,13 @@ class PmRelMachine(object):
         and friction windage losses"""
         if n > 1e-3:
             f1 = self.p*n
-            plfe = self.kpfe * (self.iqd_plfe1(iq, id, f1) + self.iqd_plfe2(iq, id, f1))
+            plfe1 = self.kpfe * self.iqd_plfe1(iq, id, f1)
+            plfe2 = self.kpfe * self.iqd_plfe2(iq, id, f1)
+            if hasattr(self, 'kpfe_s'):
+                plfe1 = self.kpfe_s * self.iqd_plfe1(iq, id, f1)
+            if hasattr(self, 'kpfe_r'):
+                plfe2 = self.kpfe_r * self.iqd_plfe2(iq, id, f1)
+            plfe = plfe1 + plfe2
             pmag = self.kpmag * self.iqd_plmag(iq, id, f1)
             return (plfe + pmag + self.pfric(n))/(2*np.pi*n)
         return 0
@@ -927,10 +933,10 @@ class PmRelMachine(object):
         plfe1 = self.iqd_plfe1(iq, id, f1)
         plfe2 = self.iqd_plfe2(iq, id, f1)
         plmag = self.iqd_plmag(iq, id, f1)
-        plfe = plfe1 + plfe2 + plmag
+        plfe = plfe1 + plfe2
         plfric = self.pfric(n)
         plcu = self.betai1_plcu(i1, 2 * np.pi * f1)
-        pltotal = plfe + plcu + plfric
+        pltotal = plfe + plcu + plfric + plmag
         p1 = pmech + pltotal
         if np.abs(pmech) < 1e-12:
             eta = 0  # power to low for eta calculation
@@ -1153,11 +1159,15 @@ class PmRelMachine(object):
         f1 = np.array(r['n'])*self.p
         plfe1 = self.kpfe*self.iqd_plfe1(np.array(r['iq']), np.array(r['id']), f1)
         plfe2 = self.kpfe*self.iqd_plfe2(np.array(r['iq']), np.array(r['id']), f1)
+        if hasattr(self, 'kpfe_s'):
+            plfe1 = self.kpfe_s*self.iqd_plfe1(np.array(r['iq']), np.array(r['id']), f1)
+        if hasattr(self, 'kpfe_r'):
+            plfe2 = self.kpfe_r*self.iqd_plfe2(np.array(r['iq']), np.array(r['id']), f1)
         plmag = self.kpmag*self.iqd_plmag(np.array(r['iq']), np.array(r['id']), f1)
-        plfe = plfe1 + plfe2 + plmag
+        plfe = plfe1 + plfe2
         plcu = self.betai1_plcu(np.array(r['i1']), 2*np.pi*f1)
         plfw = self.pfric(2*np.pi*f1)
-        pltotal = plfe + plcu + plfw
+        pltotal = plfe + plcu + plfw + plmag
         r['pmech'] = pmech.tolist()
         r['plfe'] = plfe.tolist()
         r['plcu'] = plcu.tolist()

femagtools/machine/sm.py

@@ -22,7 +22,7 @@ eecdefaults = {
     'tcu2': 20,
     'rotor_mass': 0,
     'kfric_b': 1,
-    'kpfe': 1 # iron loss factor
+    'kpfe': 1 # common iron loss factor
 }
 
 logger = logging.getLogger('sm')
@@ -76,7 +76,13 @@ def parident(workdir, engine, machine,
             raise ValueError('i1_max missing')
         i1_max = kwargs['i1_max']
 
-    ifnom = machine['rotor']['ifnom']
+
+    if "magnetFsl" in machine["magnet"]:
+        rotorkey = "magnet"
+    else:
+        rotorkey = "rotor"
+
+    ifnom = machine[rotorkey]['ifnom']
     exc_logspace = True
     ifmin, ifmax = ifnom/4, 1.4*ifnom
     if exc_logspace:
@@ -197,7 +203,7 @@ def parident(workdir, engine, machine,
     if simulation['calculationMode'] == 'ld_lq_fast':
         dqpars = dict(m=3, p=b['machine']['p'],
                       r1=float(r1),
-                      r2=machine['rotor'].get('resistance', 1),
+                      r2=machine[rotorkey].get('resistance', 1),
                       rotor_mass=rotor_mass, kfric_b=1,
                       ldq=[dict(
                           ex_current=b['machine']['ex_current'],
@@ -214,7 +220,7 @@ def parident(workdir, engine, machine,
     else:
         dqpars = dict(m=3, p=b['machine']['p'],
                       r1=r1,
-                      r2=machine['rotor'].get('resistance', 1),
+                      r2=machine[rotorkey].get('resistance', 1),
                       rotor_mass=rotor_mass, kfric_b=1,
                       psidq=[dict(
                           ex_current=b['machine']['ex_current'],
@@ -387,8 +393,13 @@ class SynchronousMachine(object):
             and friction windage losses"""
         if n > 1e-3:
             f1 = self.p*n
-            plfe = self.kpfe * (self.iqd_plfe1(iq, id, iex, f1)
-                                + self.iqd_plfe2(iq, id, iex, f1))
+            plfe1 = self.kpfe * self.iqd_plfe1(iq, id, iex, f1)
+            plfe2 = self.kpfe * self.iqd_plfe2(iq, id, iex, f1)
+            if hasattr(self, 'kpfe_s'):
+                plfe1 = self.kpfe_s * self.iqd_plfe1(iq, id, iex, f1)
+            if hasattr(self, 'kpfe_r'):
+                plfe2 = self.kpfe_r * self.iqd_plfe2(iq, id, iex, f1)
+            plfe = plfe1 + plfe2
             return (plfe + self.pfric(n))/(2*np.pi*n)
         return 0
 

femagtools/mcv.py

@@ -1173,7 +1173,10 @@ class MagnetizingCurve(object):
         mcv = self.find_by_name(name)
         if not mcv:
             bname = name
-            filename = ''.join((name, ext))
+            filename = name if pathlib.Path(name).suffix.upper() == ext \
+                else ''.join((name, ext))
+            if name == 'dummy':
+                return filename
             # check fillfac and readmcv
             if not fillfac or fillfac == 1.0:
                 try:

femagtools/shortcircuit.py

@@ -108,11 +108,11 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
             bchsc.scData['demag'] = bchsc.demag
             if simulation.get('sim_demagn', 0):
                 dd = {'displ': [d['displ']
-                               for d in bchsc.demag if 'displ' in d],
-                     'H_max': [d['H_max']
-                               for d in bchsc.demag if 'H_max' in d],
-                     'H_av': [d['H_av']
-                              for d in bchsc.demag if 'H_av' in d]}
+                                for d in bchsc.demag if 'displ' in d],
+                      'H_max': [d['H_max']
+                                for d in bchsc.demag if 'H_max' in d],
+                      'H_av': [d['H_av']
+                               for d in bchsc.demag if 'H_av' in d]}
                 x1 = bchsc.demag[0]['current_1']
                 x2 = bchsc.demag[0]['current_2']
                 def func(phi):
@@ -121,6 +121,7 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
                 i1max = x1/np.cos(phi)
 
                 phirot = dd['displ'][0]/180*np.pi
+                logger.info("i1max %g phi %g phirot %g", i1max, phi, phirot)
                 bchsc.scData['demag'] = demag(
                     femag, machine, simulation,
                     i1max, phirot, phi, engine)
@@ -319,7 +320,7 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
     # rotor position at maximum current:
     trot = min(iav[0], iap[0])
     phirot = wm*trot + phi0
-    logger.info("phi %.1f")
+    logger.debug("phirot %.1f", phirot)
 
     scData = {
         'ia': ia.tolist(),
@@ -345,7 +346,7 @@ def demag(femag, machine, simulation, i1max, phirot, phi, engine=0):
     """demag simulation using psi-torq-rem-rot"""
     logger.info("Demagnetization processing")
     i1min = simulation.get('i1min', abs(i1max/3))
-    num_steps = 7
+    num_steps = simulation.get('num_demag_cur_steps', 7)
     b = (i1min-abs(i1max))/np.log(i1min/abs(i1max))
     a = abs(i1max)/b
     xtab = np.linspace(i1min/abs(i1max),

femagtools/templates/psi-torq-rem.mako

@@ -82,14 +82,14 @@ rotate({
     mode   = "save"         -- save initial model state
 })
 
+rotate({angle=phi, mode="absolute"})
+
 file_psi = io.open("psi-torq-rem.dat","w")
 for i=1, #curvec do
-  print(string.format(" current: %d/%d %g, %g, %g\n",
-        i, #curvec, curvec[i][1], curvec[i][2], curvec[i][3]))
-
-    rotate({angle=phi, mode="absolute"})
     psi, tq, rr = calc_flux_torq_rem(curvec[i])
 
+    print(string.format(" current: %d/%d %g, %g, %g torque %g rr %g\n",
+        i, #curvec, curvec[i][1], curvec[i][2], curvec[i][3], tq, rr))
     file_psi:write(string.format("%g ", phi))
     for k=1, 3 do
       file_psi:write(string.format("%g ", curvec[i][k]))

femagtools/templates/statorKS1.mako

@@ -0,0 +1,43 @@
+
+m.yoke_diam   = dy1
+m.inside_diam = da1
+
+m.wdg_location = -1 -- for gen_windings
+
+m.slot_angle = ${model['slot_angle']*1e3}
+m.slot_height = ${model['slot_height']*1e3}
+m.slot_h1     = ${model['slot_h1']*1e3}
+m.slot_h2     = ${model['slot_h2']*1e3}
+m.slot_bk     = ${model['slot_bk']*1e3}
+m.slot_width  = ${model['slot_width']*1e3}
+m.slot_r1     = ${model['slot_r1']*1e3}
+m.slot_r2     = ${model['slot_r2']*1e3}
+m.middle_line = ${model.get('middle_line',0)}
+m.tooth_width = ${model.get('tooth_width',0)*1e3}
+m.slot_topwidth = ${model.get('slot_topwidth',0)*1e3}
+
+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', 6)}
+% endif
+m.mcvkey_yoke = mcvkey_yoke
+
+pre_models("STATOR_KS1")
+
+if mcvkey_teeth ~= nil then
+  if m.inside_diam > m.yoke_diam then
+     r = (m.inside_diam - m.slot_height)/2
+  else
+     r = (m.inside_diam + m.slot_height)/2
+  end
+  x0, y0 = pr2c(r, 2*math.pi/m.tot_num_slot + m.zeroangl/180*math.pi)
+   def_mat_fm_nlin(x0, y0, "blue", mcvkey_teeth, m.rlength)
+end
+
+%if model.get('thcond', 0) and model.get('thcap', 0):
+stator_thcond = ${model.get('thcond', 24)}
+stator_thcap = ${model.get('thcap', 480)}
+stator_density = ${model.get('density', 7700)}
+%endif

{femagtools-1.8.18.dist-info → femagtools-1.8.19.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: femagtools
-Version: 1.8.18
+Version: 1.8.19
 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.8.18.dist-info → femagtools-1.8.19.dist-info}/RECORD

@@ -1,9 +1,9 @@
-femagtools/__init__.py,sha256=dnFwrc3_Cq8UXFY0_zaoeyPv_i-P_HnEkfOG-6Hwr4U,1601
+femagtools/__init__.py,sha256=k1SL4nzTdLCU7dFO7Qd0V59z23xi1pUBL0lTp770Lho,1601
 femagtools/airgap.py,sha256=ROm4uhZjYiO0CxmFnpgiaNY9x3khlO8LBLmp5Yh5RLk,1973
 femagtools/amazon.py,sha256=O1ICuv21XDAJi1qK1Sigs2TdS6hDZP19OzvmE2t76wU,12069
 femagtools/amela.py,sha256=2q-Xsj6i6nQ3iKheBR1vQ4FulJfF1i-L8w3a3U8GYWo,4362
 femagtools/asm.py,sha256=CiL0KWaF4P7O6-VwmGLdva_icwmPrPiI-TFQ19XYTKk,7660
-femagtools/bch.py,sha256=e6kKyp4iaGb-GPMxwq5LgcyA0GQxteRJDfZsLZVfLyw,75732
+femagtools/bch.py,sha256=RHdQreeO2KuJaAVTXy2OUOgPGyHMtLlnKqYjPnZJRuY,76757
 femagtools/bchxml.py,sha256=KrRjAdrUPZXmiWvonu9HhpG_NvImMBpiXWTL4iSr4kE,3142
 femagtools/condor.py,sha256=J8z9iBdvrGu3I1eFNoyKV8AXzRoTEPGLSak6cXUQxAM,10766
 femagtools/conductor.py,sha256=rXO7c7Qh_s7JpgILmLd4IbG64vP6Eh143YF9u25Mdwg,1076
@@ -24,13 +24,13 @@ femagtools/google.py,sha256=ugRyHY1zBjHR4aNfbA7GeF-ZU_NgleuVTZaWpi_XLT4,17144
 femagtools/grid.py,sha256=s7LfKKLm2H4-cza2kSEANq6vwxq10Su3TJl3kHShHRA,1561
 femagtools/heat_source_network.py,sha256=dz3nTK084SR2fyy1167wlpBlGrzv54OqCCGKPNWqpsU,16836
 femagtools/hxy.py,sha256=PkiZ_-CRhtvtpkmLAP8iMtwvzh7CjKGGcAbOhFb4Nls,6275
-femagtools/isa7.py,sha256=8nQtl9Rcceyay9fSlhWu5zeigCyQ7rFQkPLWrYLU1bw,68345
+femagtools/isa7.py,sha256=_bJzDLDTAt6qiXks5UF-xdTuuSjMebmSPiQvB6KJzdE,68552
 femagtools/jhb.py,sha256=stJxkmzHpfUIBVcFw7jWbV5KN9_EFqzOCgacyhUqWvM,1779
 femagtools/job.py,sha256=sh4yk8RVEFai7YDBMsVg19p9xEd6_sfyNX5WQSY7HEY,11726
 femagtools/leakinduc.py,sha256=4IGZaV8S1ZG6L3hgZsCXqMsMNRH4F88l9EsvUjSXDSE,999
 femagtools/losscoeffs.py,sha256=7B29VdEsmv8HSP749X3QBb_E-XN6Z9dvNleKiRLWaMI,7721
 femagtools/magnet.py,sha256=Nuk060bT4Wa3lX74HdefqTTtUxLaERDSBYTTpbi6KP4,1093
-femagtools/mcv.py,sha256=nVemXwRPHkvlz7IIwnUONfQglnOcTnp3CsPwU1eG3OI,48604
+femagtools/mcv.py,sha256=ICXXbF5KGUsi91HktYuxzKcII-i96aBXkJzNtwkLy1Q,48740
 femagtools/me.py,sha256=z6RJkvSbgMmorCQTxKvq44uIYKh82uYYExjkNePJCmE,1813
 femagtools/model.py,sha256=dk9x-iqRzgOTdTCeU_ynUZGb1bt4FvU1ZGMPXytMbUg,17965
 femagtools/moproblem.py,sha256=kOP8pRdD8YXz28_M2WKnFgl3eeJ7tqg49ohoazsmUOg,2825
@@ -43,7 +43,7 @@ femagtools/opt.py,sha256=wBU0yh3hZlNti_zfIvtKcPg1EJrnE3I1BqmVxLGWixU,8753
 femagtools/parstudy.py,sha256=eHOcHHZAQMPnYwyQpnX9daZIMKhZZl8aDeEPXBgSS-k,20550
 femagtools/poc.py,sha256=yPWmpi8Q2g7NmpAi2YV5ezyo0VUj67EK0tcX2wikerw,7207
 femagtools/semi_fea.py,sha256=WZtYKrzhDruETyuEW2kpiNp9OaA7Hheq3qJiAIYtsjg,3475
-femagtools/shortcircuit.py,sha256=Yt-DqBAqR5r8xcOgECL-vYUYyJgLlgw0UEmfvfhE15o,14601
+femagtools/shortcircuit.py,sha256=9wulzRQamfgbRdjH90eukqjuxOgO6UU2m97W7LkGFP8,14734
 femagtools/tks.py,sha256=mDi45S5go9-jwALh6rS9RWPoOFBORZm0-XL4ECjSf_8,7531
 femagtools/ts.py,sha256=yoYjpKrr_0b-tHfsX5azJEBXHUs9PN8P-SMhbjjRhCA,48381
 femagtools/utils.py,sha256=G9U-C8ULcdGq9Ix6VEtDZ9dw7hjJHBjG3Otlka4wmU0,1787
@@ -52,31 +52,31 @@ femagtools/vtu.py,sha256=Sf83dHIfCKY2km-MIUHKKoj-JKN4PDX7kkPLZXyIYY4,10723
 femagtools/windings.py,sha256=eGRoDbi9yruiWHqZysamBLPJefw8IQX3Lq4KpG4oIKo,28216
 femagtools/zmq.py,sha256=62x5VRk0TMNER0-EZ8E28IdLKzsttlbxy1U_3wocNLc,9618
 femagtools/dxfsl/__init__.py,sha256=MywcCdpKPKs4qJBJJgeDsikJFJ2P48dbTuNk303f5pM,76
-femagtools/dxfsl/area.py,sha256=MRIta_2V5UhJdbKQa4KbyLJi6eTt86xLcPFTN91jlUk,70652
-femagtools/dxfsl/areabuilder.py,sha256=-LqJivzrBEs8g825yMnTI0KJZuAVz075Y_iDag2hteA,36947
+femagtools/dxfsl/area.py,sha256=ccRBlD3IeZOW5oiu23ROhtfnpx1LpjQ_E7MbV_HoArU,70646
+femagtools/dxfsl/areabuilder.py,sha256=H416_u2796F8nJwqa6EI2gCw-5Ay7cCpRRz3_39u42k,37916
 femagtools/dxfsl/concat.py,sha256=F6scwesxyOmfmKQ5kGspNCxA71Yz6QgxFL7lTj3hsaI,13385
 femagtools/dxfsl/conv.py,sha256=rAG_r2twWtcZyLKe8L8gYcC-n-JMG-dK1iMmd9yviTQ,12237
-femagtools/dxfsl/converter.py,sha256=M9x4IjWRxamCFtLq5sag7-Lxanpn_7pioaBjsp4BudE,41577
+femagtools/dxfsl/converter.py,sha256=LCzKF9dAKywJcjCPCavSM2jxilyO6R_kDMdctF4KRJE,41695
 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=QwfR3i20ossNByfAtM7GyTz5yvcR3vnpL2T3-HOeebk,27855
+femagtools/dxfsl/fslrenderer.py,sha256=L8qymxhrxDvNg9LLwAQgDXM1EU3yA1L3BoYpkenECEs,28005
 femagtools/dxfsl/functions.py,sha256=1RFT2YPR_rTJSKtTqIoO8Z-s_kXKIp95zed83SM0gZg,12784
-femagtools/dxfsl/geom.py,sha256=Y32mfz7M4HYQdMwzrvmUyf86kfLZYtRzC6oHgf8LILs,185782
+femagtools/dxfsl/geom.py,sha256=d-HU4yV6j9RA8PeIvesMDvXBc4xIrKXphmBI2e3_QxA,186927
 femagtools/dxfsl/journal.py,sha256=r4z52av3k95MjwzypgUJpj8sSAeQoJsS81Uqs1IBLVw,4265
-femagtools/dxfsl/machine.py,sha256=Dlz7NnHFUyiWq8pZiccCULdTPHLitnPW9xUY0hvVcK4,59131
+femagtools/dxfsl/machine.py,sha256=wtUqLAmq4Imd6uoPwrhZ5h0MCku3Mihrpqx7QycFYng,63062
 femagtools/dxfsl/plotrenderer.py,sha256=q2cORuxJEf1Ws6oCY9c0gF6N3kDrcI6WOz3u5Vl6R_c,13823
 femagtools/dxfsl/shape.py,sha256=uQqbgXIA2_KP2XRdhCfVfGWjcjwzhJ5t9RhiqR9R98c,61668
 femagtools/dxfsl/svgparser.py,sha256=RY2TU9MK6gOaNmI6w6RNqcw7H9YGmK-NUwvdylKBcsE,3763
 femagtools/dxfsl/symmetry.py,sha256=bGDSZhs6VOS-gp4C9eW0tjyMMec4BVFVZ0NpGXV3H0U,44660
-femagtools/machine/__init__.py,sha256=V1u-O4vsA7K_ZqBINNl-uD9dcoyBkmh4wkH0czrFkMU,7538
+femagtools/machine/__init__.py,sha256=RjJdy1J_9-_FEvdqdBtIjGjqF93NRzDfU5VS-z_6ARI,7557
 femagtools/machine/afpm.py,sha256=_Ei1FMuoC1GiI0z90qnyuxNrefkmeRdtDZKm20glzNY,40711
-femagtools/machine/effloss.py,sha256=lR-20LeKGgCW77x5vCzGjT9jXvqKmhf2YwbIeeNzqAI,17341
+femagtools/machine/effloss.py,sha256=jNgo9OGOnLRoZ6Mw2Lf8xOpAQWOBxX5HH4F-WzPOW0A,17687
 femagtools/machine/im.py,sha256=5wYjsEQIiKR62M2M0rA8zmybWQDVjpoazXJPRKyQOvM,40331
-femagtools/machine/pm.py,sha256=1ohA-jP1GES-HIzZ-LD0bmK1LxGGGpcgx5I6wm2m1Eo,70511
+femagtools/machine/pm.py,sha256=fKKNsnUQkO9_zz3-SC9u9OCjw3hw7Lj4FImB4ZlHrWQ,71040
 femagtools/machine/sizing.py,sha256=QO-k-UALmSPFNf8ajJPDnzKtlbkiAhX1DqWCRLr-H9k,32306
-femagtools/machine/sm.py,sha256=pGWWvlm68p8ieNMnGZuyBU5ncfx2Huw7DwRvSyTwHmY,40698
+femagtools/machine/sm.py,sha256=SwidHYI-BEGiZQMm9rYTnIuqJN121RgIQ9QetYl3fic,41066
 femagtools/machine/utils.py,sha256=HRM9UHY0UwuBWyK2dAfwlPuvMkXYBVqHlmEsUIdSNJk,21694
 femagtools/moo/__init__.py,sha256=zinmWEOrsEz6DmMX0Dbn4t6_1UR-p4bEGqyR1wUQk_Q,175
 femagtools/moo/algorithm.py,sha256=e-Cgp2rp_hG9DXqWqluzQGNIWvCfthUgLD8O-aVPofA,5763
@@ -151,7 +151,7 @@ femagtools/templates/pm_sym_loss.mako,sha256=FNAvi_gmTXsGylrpi7lLKPoOOcNCV1mG6rc
 femagtools/templates/prepare_thermal.mako,sha256=V3W6BGW7gjY8Lg2qzvGDi8rxx3JvPzrWoABDvHKyq54,9539
 femagtools/templates/psd_psq_fast.mako,sha256=IOZx04JhVleAAbBOPWk9gEwDyT28z0zkF9tyEBteRPU,1428
 femagtools/templates/psi-torq-rem-rot.mako,sha256=A1KOsYNSJhIJfumF-egnU-HUfNMPeX-XSPL_WsoE1Cw,3579
-femagtools/templates/psi-torq-rem.mako,sha256=N9AcWV0_c2jvZCr-LOW6QqDC7QIbZ-cVZ2fQ_Jw61KA,3099
+femagtools/templates/psi-torq-rem.mako,sha256=2HnPoipTeb9I69ysvgidwdHR0DxBKPxr2W0YJEmwXoU,3121
 femagtools/templates/psi-torq-rot.mako,sha256=_iT-IbgeC28wQzMVfi7uIN0cfp5pZ6d1mpLsoQrMx2c,2646
 femagtools/templates/ring.mako,sha256=Cuc_FuCPWZM-g3TxHqzTdjknYEJSUgP-y64gp8pekDI,643
 femagtools/templates/rot_hsm.mako,sha256=eh50TbpWNUALK9_7wOOJ7KPewHos7JExAfMACbPlXYc,973
@@ -166,13 +166,14 @@ femagtools/templates/stator2.mako,sha256=7Ae9sfaX7H4ummL6-g8iG42ArUvl6J809TW2tOd
 femagtools/templates/stator3Linear.mako,sha256=pNe3C1wT0W2C0qePo3sEyebW1z_dpTuJzg0r5kf3JQY,760
 femagtools/templates/stator4.mako,sha256=Jq8pfIuOmmpyGOL1z2aQZfbwMS5-Zyn6OGJ51LCBVKs,1179
 femagtools/templates/statorBG.mako,sha256=fh0cVOZVWyLojlGxWJoFz2pvdL6Yxy4xzhY-Joc2xeg,893
+femagtools/templates/statorKS1.mako,sha256=uqisqazTzopmhjUR8O660yIfsexqxj4ISHaNZIdwTSo,1285
 femagtools/templates/statorRing.mako,sha256=_X8t9oAD_6SZ_MlLc450SkN4C6pH4dG5LS09D8bv9SE,2071
 femagtools/templates/statorRotor3.mako,sha256=6ycHlkSnk-TKFdoxiOqjpr6Pk0l634w3_O94vvRP4BI,4357
 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
 femagtools/templates/torq_calc.mako,sha256=PH2IXg9ysi0w8N_8YB0IsE3rRj2VE2AYkGortQxFGfQ,2424
-femagtools-1.8.18.dist-info/licenses/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
+femagtools-1.8.19.dist-info/licenses/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_afpm.py,sha256=ge5CXnVQ7E5gVViTI9hQOC0hHetBci18pY9prbUCAqU,16849
 tests/test_airgap_induction.py,sha256=cmpy1og59oWEyCO4oF_zDuc1DUwCbdeebNL1ujpZza4,1065
@@ -222,8 +223,8 @@ 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.8.18.dist-info/METADATA,sha256=U9-02Wrkc6rrxUZbtE0hJcLIL5G885FBxrSfDt0Ng2I,6221
-femagtools-1.8.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-femagtools-1.8.18.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
-femagtools-1.8.18.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.8.18.dist-info/RECORD,,
+femagtools-1.8.19.dist-info/METADATA,sha256=t50AFbbiCAWPpTQ6fp1FO25ZkCOY1QJMUtN-WX2Lyu0,6221
+femagtools-1.8.19.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+femagtools-1.8.19.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
+femagtools-1.8.19.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
+femagtools-1.8.19.dist-info/RECORD,,