femagtools 1.6.5__py3-none-any.whl → 1.6.6__py3-none-any.whl

femagtools/dxfsl/symmetry.py

@@ -12,9 +12,10 @@ import logging
 import sys
 from femagtools.dxfsl.shape import Element, Line
 from femagtools.dxfsl.area import Area
-from femagtools.dxfsl.functions import alpha_angle, positive_angle
+from femagtools.dxfsl.functions import alpha_angle, positive_angle, is_same_angle
 from femagtools.dxfsl.functions import min_angle, max_angle, gcd, point
-from femagtools.dxfsl.functions import less_equal, less
+from femagtools.dxfsl.functions import less_equal, less, points_are_close
+from femagtools.dxfsl.functions import line_m, line_n, mirror_point
 
 logger = logging.getLogger('femagtools.symmetry')
 
@@ -38,10 +39,18 @@ class Symmetry(object):
         self.geom = geom
         self.startangle = startangle
         self.endangle = endangle
+        self.delta_check_count = 0
+        self.delta_angle_korr = 0.0
         self.rtol = rtol
         self.atol = atol
-
-        logger.debug("Symmetry(rtol=%s, atol=%s)", rtol, atol)
+        self.full = False
+        if np.isclose(self.startangle, self.endangle):
+            self.alpha = 2.0*np.pi
+            self.full = True
+        else:
+            self.alpha = alpha_angle(self.startangle, self.endangle)
+            self.full = False
+        logger.debug("Symmetry(alpha=%s, rtol=%s, atol=%s)", self.alpha, rtol, atol)
 
     def __str__(self):
         return "rtol: {}\n".format(self.rtol) + \
@@ -62,6 +71,10 @@ class Symmetry(object):
             return False
         return True
 
+    def calc_mid_angle(self, a):
+        return positive_angle(alpha_angle(self.startangle,
+                                          a.get_mid_angle(self.geom.center)))
+
     def find_symmetry(self):
         arealist = self.geom.list_of_areas()
         logger.debug("begin of Symmetry::find_symmetry: %s areas available", len(arealist))
@@ -71,18 +84,17 @@ class Symmetry(object):
 
         areas = []
         for a in arealist:
-            areas.append((a.get_alpha(),
-                          a.get_mid_angle(),
-                          a.min_dist,
-                          a.height,
+            areas.append((round(a.get_alpha(self.geom.center), 3),
+                          round(a.min_dist, 1),
+                          round(a.height, 1),
+                          self.calc_mid_angle(a),
                           a))
-        areas.sort()
-        parts_possible = None
+        areas.sort(reverse=True)
 
-        a0_alpha, a0_mid_angle, a0_min_dist, a0_height, a0 = areas[0]
+        a0_alpha, a0_min_dist, a0_height, a0_mid_angle, a0 = areas[0]
         equal_areas = [(a0_mid_angle, a0)]
-
-        for a1_alpha, a1_mid_angle, a1_min_dist, a1_height, a1 in areas[1:]:
+        check_rslt = []
+        for a1_alpha, a1_min_dist, a1_height, a1_mid_angle, a1 in areas[1:]:
             if self.equal_area(a0_min_dist, a0_height, a0_alpha,
                                a1_min_dist, a1_height, a1_alpha,
                                rtol=0.01, atol=0.05):
@@ -92,10 +104,8 @@ class Symmetry(object):
                 equal_areas.append((a1_mid_angle, a1))
             else:
                 parts = self.check_delta(equal_areas)
-                if parts_possible is None:
-                    parts_possible = parts
-                else:
-                    parts_possible = self.calc_parts(parts_possible, parts)
+                check_rslt.append((a0.area_size(), parts, len(equal_areas), a0))
+
                 equal_areas = [(a1_mid_angle, a1)]
                 a0_min_dist = a1_min_dist
                 a0_height = a1_height
@@ -103,105 +113,119 @@ class Symmetry(object):
                 a0 = a1
 
         parts = self.check_delta(equal_areas)
-        if parts_possible is None:
-            parts_possible = parts
-        else:
-            parts_possible = self.calc_parts(parts_possible, parts)
+        check_rslt.append((a0.area_size(), parts, len(equal_areas), a0))
 
-        if parts_possible is None:
-            parts_possible = 0
-        if parts_possible < 2:
+        parts = self.get_symmetry_parts(check_rslt)
+        if parts < 2:
             logger.debug("end of Symmetry::find_symmetry: no symmetry")
-            return parts_possible
-    
+            return parts
+
         self.geom.clear_cut_lines()
-        for alpha in self.symmetry_lines(parts_possible,
+        for alpha in self.symmetry_lines(parts,
                                          self.startangle,
                                          self.endangle):
-            min_radius = max(10, self.geom.min_radius - 10)
+            plus = self.geom.max_radius / 10
+            min_radius = max(10, self.geom.min_radius - plus)
             p1 = point(self.geom.center, min_radius, alpha)
-            p2 = point(self.geom.center, self.geom.max_radius+10, alpha)
+            p2 = point(self.geom.center, self.geom.max_radius + plus, alpha)
             line = Line(Element(start=p1, end=p2))
             line.init_attributes(color='green')
             self.geom.add_cut_line(line)
-                    
-        logger.debug("end of Symmetry::find_symmetry")
-        return parts_possible
+
+        logger.debug("end of Symmetry::find_symmetry: -> %s", parts)
+        return parts
     
     def check_delta(self, area_list):
-        logger.debug("==> %s equal areas", len(area_list))
+        logger.debug("begin of check_delta: %s equal areas", len(area_list))
         if not area_list:
+            logger.debug("end of check_delta: no areas")
             return None
 
         if len(area_list) == 1:
             mid_angle, a = area_list[0]
-            if np.isclose(a.min_angle, self.startangle) and \
-               np.isclose(a.max_angle, self.endangle):
+            alpha = a.get_alpha(self.geom.center)
+            if np.isclose(alpha, self.alpha):
+                logger.debug("end of check_delta: one area from start to end")
                 return None  # ok
 
+        self.delta_check_count += 1
         area_list.sort()
-        start = self.startangle
-        mid_angle, a = area_list[0]
 
-        delta = alpha_angle(start, mid_angle) * 2
+        mid_angle, a = area_list[0]
+        delta = positive_angle(mid_angle * 2)
+        delta_total = mid_angle
         delta_list = [delta]
-        logger.debug("geom: start=%s,  end=%s", self.startangle, self.endangle)
+
+        logger.debug("First mid = %s, delta = %s", mid_angle, delta)
         logger.debug("%s:  d=%s,  h=%s,  a=%s, mid=%s, delta=%s",
                      a.identifier(),
                      a.min_dist,
                      a.height,
-                     a.get_alpha(),
-                     a.get_mid_angle(),
+                     a.get_alpha(self.geom.center),
+                     mid_angle,
                      delta)
-        logger.debug("  min=%s,  max%s",
-                     a.min_angle,
-                     a.max_angle)
 
-        start = mid_angle
+        geom_alpha = alpha_angle(self.startangle, self.endangle)
+        geom_alpha = positive_angle(geom_alpha)
+
+        start_angle = mid_angle
         for mid_angle, a in area_list[1:]:
-            delta = alpha_angle(start, mid_angle)
+            delta_angle = alpha_angle(start_angle, mid_angle)
+            delta = positive_angle(delta_angle)
+            delta_total += delta_angle
             delta_list.append(delta)
 
             logger.debug("%s:  d=%s,  h=%s,  a=%s, mid=%s, delta=%s",
                          a.identifier(),
                          a.min_dist,
                          a.height,
-                         a.get_alpha(),
-                         a.get_mid_angle(),
+                         a.get_alpha(self.geom.center),
+                         mid_angle,
                          delta)
-            logger.debug("  min=%s,  max%s",
-                         a.min_angle,
-                         a.max_angle)
-
-            start = mid_angle
+            start_angle = mid_angle
             
-        delta = alpha_angle(start, self.endangle) * 2
+        delta_angle = alpha_angle(start_angle, geom_alpha)
+        delta = positive_angle(delta_angle * 2)
+        delta_total += delta_angle
         delta_list.append(delta)
         logger.debug("final delta=%s", delta)
 
+        if not np.isclose(geom_alpha, delta_total):
+            logger.debug("-- deltas: %s", delta_list)
+            logger.debug("end of check_delta: BAD DELTA %s, (expected %s)",
+                         delta_angle, geom_alpha)
+            return 0  # very bad
+
         sz = len(delta_list)
         mid = int(sz / 2)
         ix1 = 0
         ix2 = sz - 1
+        first_last_bad = False
         for ix1 in range(0, mid):
             if not np.isclose(delta_list[ix1], delta_list[ix2], rtol=1e-3, atol=1e-3):
-                logger.debug("NO SYM")
-                return 0
+                if self.full and \
+                   self.delta_check_count == 1 and \
+                   ix1 == 0 and \
+                   self.delta_angle_korr == 0.0:
+                    first_last_bad = True
+                else:
+                    logger.debug("end of check_delta: NO SYM")
+                    return 0
             ix2 -= 1
 
-        geom_alpha = alpha_angle(self.startangle, self.endangle)
-        delta_alpha = 0.0
-        for d in delta_list:
-            delta_alpha += d
-
-        geom_alpha = positive_angle(geom_alpha)
-
-        delta_alpha -= delta_list[0] / 2
-        delta_alpha -= delta_list[-1] / 2
-        delta_alpha = positive_angle(delta_alpha)
-        if not np.isclose(geom_alpha, delta_alpha):
-            logger.debug("BAD DELTA ?!?")
-            return 0  # very bad
+        if first_last_bad:
+            delta_korr = (delta_list[0] + delta_list[-1]) / 2.0
+            logger.debug("STARTANGLE CORRECTION")
+            self.delta_angle_korr = (delta_korr - delta_list[0]) / 2
+            logger.debug("-- delta[0] from %s to %s", delta_list[0], delta_korr)
+            logger.debug("Delta Angle Korr = %s", self.delta_angle_korr)
+            delta_list[0] = delta_korr
+            delta_list[-1] = delta_korr
+            assert(self.full)
+            self.startangle = self.startangle - self.delta_angle_korr
+            self.endangle = self.endangle - self.delta_angle_korr
+            logger.debug("New startangle = %s", self.startangle)
+            logger.debug("Delta List: %s", delta_list)
 
         d1 = delta_list[0]
         d1_count = 1
@@ -212,9 +236,10 @@ class Symmetry(object):
                 d1_count += 1
 
         if d1_count == len(delta_list):
-            logger.debug("SYMMETRY FOUND")
+            logger.debug("end of check_delta: SYMMETRY FOUND")
             return d1_count -1  # very simple
         if len(delta_list) < 2:
+            logger.debug("end of check_delta: One delta only ?!")
             return 0
 
         logger.debug("index of delta %s = %s", d1, inx_list)
@@ -227,15 +252,51 @@ class Symmetry(object):
                 return 0
             x1 = x2
         
-        logger.debug("SYMMETRY FOUND")
+        logger.debug("end of check_delta: SYMMETRY FOUND")
         return len(inx_list) -1
 
+    def get_symmetry_parts(self, check_rslt):
+        max_size = 0
+        max_areas = 0
+        parts_possible = None
+
+        check_rslt.sort(reverse=True)
+        for size, parts, count, area in check_rslt:
+            logger.debug("Result: %s, %s, %s", size, parts, count)
+
+        for size, parts, count, area in check_rslt:
+            if parts is not None and parts > 0:
+                max_size = max(max_size, size)
+                max_areas = max(max_areas, count)
+
+        logger.debug("max size: %s,  max areas: %s", max_size, max_areas)
+
+        for size, parts, count, area in check_rslt:
+            if parts is not None and parts <= 1:  # critical
+                if count <= max(1, max_areas / 5):
+                    if size < max_size / 25:
+                        parts = None
+
+            parts_possible = self.calc_parts(parts_possible, parts)
+
+        if parts_possible is None:
+            parts_possible = 0
+        return parts_possible
+
     def calc_parts(self, parts1, parts2):
         logger.debug("Calc symmetry Parts (%s, %s)", parts1, parts2)
         if parts2 is None:
+            logger.debug("return %s parts", parts1)
             return parts1
-
-        return gcd(parts1, parts2)
+        if parts1 is None:
+            logger.debug("return %s parts", parts2)
+            return parts2
+        if parts1 == 0 or parts2 == 0:
+            logger.debug("return %s parts", 0)
+            return 0
+        parts = gcd(parts1, parts2)
+        logger.debug("return %s parts", parts)
+        return parts
 
     def symmetry_lines(self, parts, startangle, endangle):
         logger.debug("begin symmetry_lines from %s to %s",
@@ -249,7 +310,10 @@ class Symmetry(object):
         while less(start, endangle):
             yield start
             start += delta
-            
+
+        if is_same_angle(startangle, endangle):
+            yield start
+
         # Damit man anschliessend ohne Umstände schneiden kann.
         self.geom.sym_startangle = startangle
         self.geom.sym_endangle = startangle + delta
@@ -259,3 +323,48 @@ class Symmetry(object):
         self.geom.sym_area.sym_startangle = self.geom.sym_startangle
         self.geom.sym_area.sym_endangle = self.geom.sym_endangle
         logger.debug("end symmetry_lines")
+
+    def check_symmetry_of_mirror(self, mirror_geom, mirrorangle):
+        logger.debug("begin of Symmetry::check_symmetry_of_mirror")
+        assert(mirror_geom is not None)
+
+        axis_p = point(self.geom.center, self.geom.max_radius, mirrorangle)
+        axis_m = line_m(self.geom.center, axis_p)
+        axis_n = line_n(self.geom.center, axis_m)
+
+        def counterpart_found(node, nodes, rtol, atol):
+            hits = 0
+            for n in nodes:
+                if points_are_close(node, n, rtol, atol):
+                    logger.debug(" ---- %s is %s", node, n)
+                    return True
+            return False
+
+        def check_differences(geom, mirror_geom):
+            geom_ag_nodes = []
+            geom_nodes = [n for n in geom.g.nodes() if not (n in geom_ag_nodes)]
+
+            hit = 0
+            for n in geom_nodes:
+                mirror_n = mirror_point(n, geom.center, axis_m, axis_n)
+                if counterpart_found(mirror_n,
+                                     mirror_geom.g.nodes(),
+                                     self.rtol,
+                                     self.atol):
+                    hit += 1
+            min_nodes = min(len(geom_nodes), int(len(geom_nodes) * 0.95) + 1)
+            logger.debug("Nodes=%s,  Counterparts=%s", len(geom_nodes), hit)
+            if hit < min_nodes:
+                return hit / len(geom_nodes)
+            else:
+                return 1.0
+
+        # ----------------
+        logger.debug("check geom - mirror")
+        f1 = check_differences(self.geom, mirror_geom)
+        logger.debug("check mirror - geom")
+        f2 = check_differences(mirror_geom, self.geom)
+        logger.debug("Factor 1: %s,  2: %s", f1, f2)
+        ok = f1 > 0.97 and f2 > 0.97
+        logger.debug("end of Symmetry::check_symmetry_of_mirror => %s", ok)
+        return ok

femagtools/isa7.py

@@ -868,14 +868,14 @@ class Isa7(object):
         except AttributeError:
             pass
 
-        try: 
+        try:
             flx_fac = 1000
-            if isinstance(reader.el_fe_induction_1, list): 
+            if isinstance(reader.el_fe_induction_1, list):
                 pass
-            else: 
-                if reader.el_fe_induction_1.dtype == 'int16': 
+            else:
+                if reader.el_fe_induction_1.dtype == 'int16':
                     flx_fac = 1000
-                else: 
+                else:
                     flx_fac = 1
             el_fe_ind = [np.array(reader.el_fe_induction_1).T/flx_fac,
                         np.array(reader.el_fe_induction_2).T/flx_fac]
@@ -1432,6 +1432,7 @@ class Element(BaseEntity):
         """return temperature of this element"""
         return sum([v.vpot[1] for v in self.vertices])/len(self.vertices)
 
+
 class SuperElement(BaseEntity):
     def __init__(self, key, sr_key, elements, nodechains, color,
                  nc_keys, mcvtype, condtype, conduc, length,

femagtools/machine/effloss.py

@@ -238,7 +238,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
                                    with_pmconst=with_pmconst, with_tmech=with_tmech)  # braking mode
     
     if kwargs.get('mesh_func', 0):
-        ntmesh = kwargs['mesh_func'](r['n'], r['T'],
+        ntmesh = kwargs['mesh_func'](r['n_type'], r['n'], r['T'],
                                     rb['n'], rb['T'], npoints)
     else: 
         ntmesh = _generate_mesh(r['n'], r['T'],

femagtools/machine/im.py

@@ -622,6 +622,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
     i_max_fact: (float) factor for maximum current to calculate no_load flux (default=2.5)
     templatedirs: (list of str) names of directories to search for templates
     """
+    cmd = kwargs.get("cmd", None)
     CON = {'open': 0, 'wye': 1, 'star': 1, 'delta': 2}
     p = machine['poles']//2
     slip = 1e-2
@@ -676,7 +677,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
 
     parstudy = femagtools.parstudy.ParameterStudy(
         workdir, condMat=condMat,
-        magnetizingCurves=magnetizingCurves)
+        magnetizingCurves=magnetizingCurves, cmd=cmd)
 
     builder = femagtools.fsl.Builder(kwargs.get('templatedirs', []))
     model = femagtools.model.MachineModel(m)

femagtools/machine/pm.py

@@ -69,6 +69,7 @@ class PmRelMachine(object):
         self.rotor_mass = 0
         self.kth1 = KTH
         self.bertotti = False
+        self.max_torque = 0.0
         self.losskeys = ['styoke_hyst', 'stteeth_hyst',
                         'styoke_eddy', 'stteeth_eddy',
                         'rotor_hyst', 'rotor_eddy',
@@ -165,6 +166,46 @@ class PmRelMachine(object):
         return iq, 0, self.torque_iqd(iq, 0)
 
     def iqd_tmech(self, torque, n, iqd0=0, with_mtpa=True):
+        """return minimum d-q-current for shaft torque"""
+        if np.abs(torque) < 1e-2:
+            return (0, 0)
+        if np.isscalar(iqd0):
+            tx = self.tmech_iqd(self.io[0], 0, n)
+            iq0 = min(0.9*self.i1range[1]/np.sqrt(2),
+                      np.abs(torque)/tx*self.io[0])
+            if torque < 0:
+                i0 = (-iq0, 0)
+            else:
+                i0 = (iq0, 0)
+            logger.debug("initial guess i0 %f -> %s tx %f torque %f",
+                        self.io[0], i0, tx, torque)
+        else:
+            i0 = iqd0
+
+        if with_mtpa:
+            k=0
+            while k < 6:
+                res = so.minimize(
+                    lambda iqd: la.norm(iqd), i0, method='SLSQP',
+                    constraints=({'type': 'eq',
+                                  'fun': lambda iqd:
+                                  self.tmech_iqd(*iqd, n) - torque}))
+                if res.success:
+                    return res.x
+                # make new initial guess:
+                tx = self.tmech_iqd(*i0, n)
+                logger.debug("k %d new guess i0 %s tx %f torque %f",
+                            k, i0, tx, torque)
+                i0=(min(0.9*self.i1range[1]/np.sqrt(2), torque/tx*i0[0]), 0)
+                k += 1
+            raise ValueError(
+                f'Torque {torque} speed {n} {i0} {res.message}')
+        def tqiq(iq):
+            return torque - self.tmech_iqd(float(iq), 0, n)
+        iq = so.fsolve(tqiq, (i0[0],))[0]
+        return iq, 0, self.tmech_iqd(iq, 0, n)
+
+    def iqd_tmech0(self, torque, n, iqd0=0, with_mtpa=True):
         """return minimum d-q-current for shaft torque"""
         if np.abs(torque) < 1e-2:
             return (0, 0)
@@ -681,17 +722,24 @@ class PmRelMachine(object):
             iq, id, T = self.mtpa(i1max)
             w1type = self.w1_umax(u1max, iq, id)
         Pmax = w1type/self.p*T
-        w1max = 2*np.pi*speedmax*self.p
         # check max speed:
-        if with_pmconst:
-            iq, id, tq = self.iqd_pmech_imax_umax(
-                speedmax, Pmax, i1max, u1max,
-                with_mtpa, with_tmech)
-        else:
-            iq, id, tq = self.iqd_imax_umax(
-                i1max, w1max, u1max,
-                T, with_mtpv=False,
-                with_tmech=with_tmech)
+        sp = speedmax
+        while sp > w1type/2/np.pi/self.p:
+            w1max = 2*np.pi*sp*self.p
+            try:
+                if with_pmconst:
+                    iq, id, tq = self.iqd_pmech_imax_umax(
+                        sp, Pmax, i1max, u1max,
+                        with_mtpa, with_tmech)
+                else:
+                    iq, id, tq = self.iqd_imax_umax(
+                        i1max, w1max, u1max,
+                        T, with_mtpv=False,
+                        with_tmech=with_tmech)
+                break
+            except ValueError:
+                sp -= 5e-2*speedmax
+        speedmax = sp
         i1 = betai1(iq, id)[1]
         if (abs(i1max) >= i1
             and round(u1max, 1) >= round(np.linalg.norm(
@@ -843,7 +891,7 @@ class PmRelMachine(object):
     def characteristics(self, T, n, u1max, nsamples=60,
                         with_mtpv=True, with_mtpa=True,
                         with_pmconst=True, with_tmech=True,
-                        with_torque_corr=False):
+                        with_torque_corr=False, **kwargs):
         """calculate torque speed characteristics.
         return dict with list values of
         id, iq, n, T, ud, uq, u1, i1,
@@ -863,6 +911,9 @@ class PmRelMachine(object):
         r = dict(id=[], iq=[], uq=[], ud=[], u1=[], i1=[], T=[],
                  beta=[], gamma=[], phi=[], cosphi=[], pmech=[], n=[])
 
+        if kwargs.get('i1max', 0):
+            w1type, T = self.w1_imax_umax(kwargs['i1max'], u1max)
+
         if np.isscalar(T):
             tmax = self.torquemax(self.i1range[1])
             tmin = 0
@@ -923,6 +974,9 @@ class PmRelMachine(object):
             if speedrange[-1] < speedrange[-2]:
                 speedrange = speedrange[:-1]
             logger.info("Speedrange T=%g Nm %s", Tf, speedrange)
+            if speedrange[-1] < nmax:
+                logger.warning("adjusted nmax %f -> %f", nmax, speedrange[-1])
+
             n3 = speedrange[-1]
             nstab = [int(nsamples*(x1-x2)/n3)
                      for x1, x2 in zip(speedrange[1:],
@@ -1135,7 +1189,12 @@ class PmRelMachineLdq(PmRelMachine):
         if np.any(beta[beta > np.pi]):
             beta[beta > np.pi] = beta - 2*np.pi
 
-        self.io = iqd((np.min(beta)+max(beta))/2, np.max(i1)/2)
+        self.betarange = min(beta), max(beta)
+        if min(beta) < -np.pi/2 and max(beta) > -np.pi/2:
+            self.io = iqd(-np.pi/4, np.max(i1)/2)
+        else:
+            self.io = iqd((np.min(beta)+max(beta))/2, np.max(i1)/2)
+
         kx = ky = 3
         if len(i1) < 4:
             ky = len(i1)-1

femagtools/machine/sm.py

@@ -46,6 +46,7 @@ def parident(workdir, engine, machine,
         speed: rotor speed in 1/s (default 160/p)
         i1_max: maximum current in A rms (default approx 3*i1nom)
         """
+        cmd = kwargs.get('cmd', None)
         da1 = machine['outer_diam']
         Q1 = machine['stator']['num_slots']
         if 'statorRotor3' in machine['stator']:
@@ -59,7 +60,7 @@ def parident(workdir, engine, machine,
         N = machine[wdgk]['num_wires']
         i1_max = round(0.28*np.pi*hs*(da1+hs)/Q1/N*Jmax*1e5)*10 * \
             machine[wdgk].get('num_par_wdgs', 1)
-
+        
         ifnom = machine['rotor']['ifnom']
         exc_logspace = True
         if exc_logspace:
@@ -78,7 +79,7 @@ def parident(workdir, engine, machine,
 
         parvar = parstudy.List(
             workdir,  condMat=condMat,
-            magnetizingCurves=magnetizingCurves)
+            magnetizingCurves=magnetizingCurves, cmd=cmd)
 
         simulation = dict(
                 calculationMode=kwargs.get('calculationMode',
@@ -240,6 +241,7 @@ class SynchronousMachine(object):
         self.kth1 = KTH
         self.kth2 = KTH
         self.skin_resistance = [None, None]
+        self.kpmag = 1
         # here you can set user defined functions for calculating the skin-resistance,
         # according to the current frequency w. First function in list is for stator, second for rotor.
         # If None, the femagtools intern default implementation is used.

femagtools/plot/nc.py

@@ -149,8 +149,7 @@ def __elements_of_subreg(isa, subreg):
         else:
             sr = [subreg]
         for s in sr:
-            for e in isa.get_subregion(s).elements():
-                yield e
+            yield from isa.get_subregion(s).elements()
     else:
         for e in isa.elements:
             yield e
@@ -232,7 +231,8 @@ def flux_density_pos(isa, ipos, subreg=[], icur=-1, ibeta=-1, cmap=DEFAULT_CMAP,
         ibeta: beta angle index or last index if -1
 
     """
-    elements = [e for e in __elements_of_subreg(isa, subreg)]
+    elements = [e for e in __elements_of_subreg(isa, subreg)
+                if e not in isa.airgap_center_elements]
     b = []
     for e in elements:
         fd = isa.flux_density(e, icur, ibeta)