femagtools 1.8.18__tar.gz → 1.8.19__tar.gz

{femagtools-1.8.18/src/femagtools.egg-info → femagtools-1.8.19}/PKG-INFO

@@ -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 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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-1.8.18 → femagtools-1.8.19}/src/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: