femagtools 1.8.10__py3-none-any.whl → 1.8.12__py3-none-any.whl

femagtools/__init__.py

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

femagtools/fsl.py

@@ -765,18 +765,15 @@ class Builder:
         if pfefunc:
             sim['loss_funct'] = pfefunc
         '''
+        if sim.get('plots') and sim.get('calculationMode', '') != 'psi-torq-rem':
+            plots = self.__render(sim, 'plots')
+        else:
+            plots = []
 
-        if sim.get('calculationMode') in ('cogg_calc',
-                                          'ld_lq_fast',
-                                          'pm_sym_loss',
-                                          'torq_calc',
-                                          'psd_psq_fast'):
-            return felosses + fslcalc
-
-        return felosses + fslcalc + self.__render(sim, 'plots')
+        return felosses + fslcalc + plots
 
     def create_shortcircuit(self, model):
-        return self.__render(model, 'shortcircuit')
+        return self.__render(model, 'shortcircuit') + self.__render(model, 'plots')
 
     def create_airgap_induc(self):
         return self.__render(dict(), 'airgapinduc')

femagtools/isa7.py

@@ -1294,13 +1294,12 @@ class Isa7(object):
         scale_factor = poles/poles_sim
         return scale_factor
 
-    def get_magnet_data(self, ibeta=0, icur=0) -> list:
+    def get_magnet_data(self, ibeta=None, icur=0) -> list:
         '''Extract magnet data from nc file
 
         Args:
             nc: nc object
-            icur, ibeta: load case
-
+            ibeta: loadcase (default: None)
         Returns:
           pm_data: list of magnet data
         '''
@@ -1350,12 +1349,6 @@ class Isa7(object):
             ecp = [e.center for e in se.elements]
             geometry = se.get_rect_geom()
 
-            bxy = []
-            for e in se.elements:
-                theta = np.arctan2(float(e.center[1]),
-                                   float(e.center[0]))
-                fd = self.flux_density(e, icur, ibeta)
-                bxy.append(Trot(-theta).dot((fd['bx'], fd['by'])))
             #= np.moveaxis(bxy, 1, 0)
             pd = dict(name='pm_data_se' + str(se.key),
                       hm=geometry['h'],
@@ -1367,16 +1360,28 @@ class Isa7(object):
                       mur=mur,
                       loadcase=ibeta,
                       numpoles=poles,
-                      bl=transform_flux_density(geometry['alpha'],
-                                                np.array(bxy)),
                       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)
         return pm_data
 
+    def get_magnet_flux_density(self, se, icur, ibeta) -> list:
+        """returns the flux density Bx, By of all elements
+        of this super element transformed to the main axis (alpha)
+        Note: get_rect_geom must be called previously.
+        """
+        bxy = []
+        for e in se.elements:
+            theta = np.arctan2(float(e.center[1]),
+                               float(e.center[0]))
+            fd = self.flux_density(e, icur, ibeta)
+            bxy.append(Trot(-theta).dot((fd['bx'], fd['by'])))
+        return transform_flux_density(se.alpha, np.array(bxy))
 
 class Point(object):
     def __init__(self, x, y):
@@ -1662,12 +1667,11 @@ class SuperElement(BaseEntity):
         # angle of main axis
         i = np.argmax(dc)
         c = np.vstack((c, c[0]))
-        alpha = np.arctan2(c[i+1, 1]-c[i, 1], c[i+1, 0]-c[i, 0])
-        if alpha < 0:
-            alpha += np.pi
+        self.alpha = np.arctan2(c[i+1, 1]-c[i, 1], c[i+1, 0]-c[i, 0])
+        #if alpha < 0:
+        #    alpha += np.pi
         return {'w': w, 'h': h, 'cxy': cxy,
-                'area': area, 'alpha': alpha}
-
+                'area': area, 'alpha': self.alpha}
 
 class SubRegion(BaseEntity):
     def __init__(self, key, sr_type, color, name, nturns, curdir, wb_key,

femagtools/leakinduc.py

@@ -22,37 +22,6 @@ def end_wdg_leak_ind_hairpin_wires(): #TODO
     return L_ew
 
 
-#def slot_leakage_inductance_round_wires(p, q, w1, num_par_wdgs, layers):
-#    '''returns slot leakage inductance per phase'''
-#    mue0 = 4*np.pi*1e-7
-#    if layers == 1:
-#        lambda_slot = 0 # tbc
-#    if layers == 2:
-#        t1 = b2/bs
-#        t2 = b1/b2
-#        t12 = b1/b2
-#        kt1 = (4*t1**2 - t1**4 - 4*np.log(t1) -3)/(4*(1 - t1)*(1 - t1**2)**2) if t1 != 1 else 0
-#        kt2 = (4*t2**2 - t2**4 - 4*np.log(t2) - 3)/(4*(1 - t2)*(1 - t2**2)**2) if t2 != 1 else 0
-#        kt12 = (t12**2 - 2*np.log(t12) - 1)/(2*(1 - t12)*(1 - t12**2)) if t12 != 1 else 0
-#        const = 0.1424 + 0.5*np.arcsin(np.sqrt(1 - (bo/b1)**2)) + ho/bo
-#        lambda_t = h2/b2*kt2 + const
-#        lambda_b = h3/bs*kt1 + h2/(b2-b1)*np.log(b2/b1) + const if b2 != b1 else h3/bs*kt1 + const
-#        lambda_tb = h2/b2*kt12 +  const
-#        lambda_slot = lambda_t + lambda_b + lambda_tb
-#    L_slot = mue0*2/(p*q)*(w1/num_par_wdgs)**2*lambda_slot
-#    return L_slot
-
-
-def slot_leak_ind_fea(): #TODO
-    '''returns slot and tooth tip leakage inductance'''
-    # make a single slot model with detailed windings
-    # run current through windings
-    # L_slot = flux / current
-    # scale to get values per phase
-    L_slot = 0
-    return L_slot
-
-
 def harm_leak_ind(E_fft, order_fft, freq, Ia): # needs to be validated
     '''returns harmonic leakage inductance per phase'''
     L_harm = []

femagtools/machine/afpm.py

@@ -56,6 +56,10 @@ def jsonify(v):
 
 
 def get_magdata(task):
+    """result func used in parstudy
+    extracts the magnet data from the NC/ISA7 for
+    subsequent magnet loss calc
+    """
     basedir = Path(task.directory)
     bchfile_list = sorted(basedir.glob(
         '*_[0-9][0-9][0-9].B*CH'))

femagtools/machine/effloss.py

@@ -222,10 +222,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         m = create_from_eecpars(xtemp, eecpars)
     else:  # must be an instance of Machine
         m = eecpars
-    if isinstance(T, list):
-        r = {'T': T, 'n': n}
-        rb = {'T': [], 'n': []}
-    else:  # calculate speed,torque characteristics
+    if np.isscalar(T):  # calculate speed,torque characteristics
         nmax = n
         nsamples = npoints[0]
         rb = {}
@@ -249,15 +246,33 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
                                    with_mtpv=with_mtpv, with_mtpa=with_mtpa,
                                    with_pmconst=with_pmconst, with_tmech=with_tmech,
                                    **kwargs)  # braking mode
-
-    if kwargs.get('mesh_func', 0):
-        ntmesh = kwargs['mesh_func'](r['n_type'], r['n'], r['T'],
+        if kwargs.get('mesh_func', 0):
+            ntmesh = kwargs['mesh_func'](r['n_type'], r['n'], r['T'],
+                                    rb['n'], rb['T'], npoints)
+        else:
+            ntmesh = _generate_mesh(r['n'], r['T'],
                                     rb['n'], rb['T'], npoints)
     else:
-        ntmesh = _generate_mesh(r['n'], r['T'],
-                                rb['n'], rb['T'], npoints)
-
-    logger.info("total speed,torque samples %d", ntmesh.shape[1])
+        nt = []
+        iq, id = m.iqd_torque(T[-1])
+        i1max = betai1(iq, id)[1]
+        logger.info("%s %s", n, T)
+        for nx in n:
+            w1 = 2*np.pi*nx*m.p
+            iq, id, tq =  m.iqd_imax_umax(i1max, w1, u1, T[-1],
+                                          with_tmech=with_tmech,
+                                          with_mtpa=with_mtpa)
+            if np.isclose(tq, T[-1]):
+                tq = T[-1]
+            for Tx in T:
+                if Tx <= tq:
+                    nt.append((nx, Tx))
+        if not nt:
+            raise ValueError("Speed, Torque Mesh is empty")
+        nsamples = len(n)
+        ntmesh = np.array(nt).T
+
+    logger.info("total speed,torque samples %s", ntmesh.shape)
     if isinstance(m, (PmRelMachine, SynchronousMachine)):
         if num_proc > 1:
             iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa,
@@ -328,7 +343,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plcu2 = m.iqd_plcu2(*iqd)
         tfric = m.tfric
         try:
-            plcu1_dc = m.iqd_plcu1(iqd[0], iqd[1], 
+            plcu1_dc = m.iqd_plcu1(iqd[0], iqd[1],
                                 np.array([0.0 for i in f1])).tolist()
             plcu1_ac = [i-j for i, j in zip(plcu1.tolist(), plcu1_dc)]
         except:
@@ -397,6 +412,6 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plcu1=plcu1.tolist(),
         plcu2=plcu2.tolist(),
         plfric=plfric.tolist(),
-        losses=ploss.tolist(), 
-        plcu1_dc=plcu1_dc, 
+        losses=ploss.tolist(),
+        plcu1_dc=plcu1_dc,
         plcu1_ac=plcu1_ac)

femagtools/machine/pm.py

@@ -315,25 +315,51 @@ class PmRelMachine(object):
                 lambda w1: la.norm(self.uqd(w1, iq, id))-u*np.sqrt(2),
                 w10)[0]
 
-    def w1_imax_umax(self, i1max, u1max):
+    def w1_imax_umax(self, i1max, u1max, with_mtpa=True, with_tmech=True):
         """return frequency w1 and torque at voltage u1max and current i1max
 
         Keyword arguments:
         u1max -- the maximum voltage (Vrms)
-        i1max -- the maximum current (Arms)"""
-        iq, id, T = self.mtpa(i1max)
-        n0 = u1max/np.linalg.norm(self.psi(iq, id))/2/2/np.pi/self.p
-        sign = -1 if i1max > 0 else 1
-        res = so.minimize(
-            lambda n: sign*self.mtpa_tmech(i1max, n)[2],
-            n0,
-            constraints={
-                'type': 'eq',
-                'fun': lambda n:
-                np.sqrt(2)*u1max - la.norm(
-                    self.uqd(2*np.pi*n*self.p,
+        i1max -- the maximum current (Arms)
+        with_mtpa -- use minimum current
+        with_tmech -- use mech torque
+        """
+        if with_mtpa:
+            iq, id, T = self.mtpa(i1max)
+            n0 = u1max/np.linalg.norm(self.psi(iq, id))/2/2/np.pi/self.p
+            if with_tmech:
+                sign = -1 if i1max > 0 else 1
+                res = so.minimize(
+                    lambda n: sign*self.mtpa_tmech(i1max, n)[2],
+                    n0,
+                    constraints={
+                        'type': 'eq',
+                        'fun': lambda n:
+                        np.sqrt(2)*u1max - np.linalg.norm(
+                            self.uqd(2*np.pi*n*self.p,
                              *self.mtpa_tmech(i1max, n)[:2]))})
-        return 2*np.pi*res.x[0]*self.p, self.mtpa_tmech(i1max, res.x[0])[2]
+                return 2*np.pi*res.x[0]*self.p, self.mtpa_tmech(i1max, res.x[0])[2]
+            return so.fsolve(lambda x: np.linalg.norm(
+                self.uqd(x, iq, id)) - u1max*np.sqrt(2),
+                2*np.pi*self.p*n0), T
+
+        iq, id = iqd(0, i1max)
+        n0 = u1max/np.linalg.norm(self.psi(iq, id))/2/2/np.pi/self.p
+        if with_tmech:
+            sign = -1 if i1max > 0 else 1
+            res = so.minimize(
+                lambda n: sign*self.tmech_iqd(iq, id, n),
+                    n0,
+                    constraints={
+                        'type': 'eq',
+                        'fun': lambda n:
+                        np.sqrt(2)*u1max - np.linalg.norm(
+                            self.uqd(2*np.pi*n*self.p, iq, id))})
+            return 2*np.pi*res.x[0]*self.p, self.tmech_iqd(iq, id, res.x[0])
+
+        return so.fsolve(lambda x: np.linalg.norm(
+                self.uqd(x, iq, id)) - u1max*np.sqrt(2),
+                2*np.pi*self.p*n0), self.torque_iqd(iq, id)
 
     def w1_u(self, u, iq, id):
         """return frequency w1 at given voltage u and id, iq current
@@ -497,16 +523,17 @@ class PmRelMachine(object):
         logger.debug("field weakening mode %.2f kW @ %.0f rpm %.1f Nm; "
                      "u1=%.0f V; plfric=%.2f W",
                      P/1000, n*60, T, u1max, self.pfric(n))
-        iq, id = self.iqd_torque_imax_umax(T, n, u1max, with_tmech=with_tmech)[:2]
+        iq, id = self.iqd_torque_imax_umax(T, n, u1max,
+                                           with_tmech=with_tmech, with_mtpa=with_mtpa)[:2]
 
         if with_tmech:
             tcon = {'type': 'eq',
                     'fun': lambda iqd:
-                    self.tmech_iqd(*iqd, n) - T}
+                    T - self.tmech_iqd(*iqd, n)}
         else:
             tcon = {'type': 'eq',
                     'fun': lambda iqd:
-                    self.torque_iqd(*iqd) - T}
+                    T - self.torque_iqd(*iqd)}
 
         res = so.minimize(lambda iqd: np.linalg.norm(iqd), (iq, id),
                           method='SLSQP',
@@ -522,7 +549,7 @@ class PmRelMachine(object):
                 log(res.x)
             if i1 > abs(i1max):
                 return self.iqd_imax_umax(i1max, w1, u1max, T,
-                                          with_mtpv=False,
+                                          with_mtpv=False, with_mtpa=with_mtpa,
                                           with_tmech=with_tmech)
             if with_tmech:
                 return *res.x, self.tmech_iqd(*res.x, n)
@@ -538,7 +565,7 @@ class PmRelMachine(object):
             log((iq, id, tq))
         return iq, id, tq
 
-    def iqd_torque_imax_umax(self, torque, n, u1max, with_tmech=False, log=0):
+    def iqd_torque_imax_umax(self, torque, n, u1max, with_tmech=False, with_mtpa=True, log=0):
         """return d-q current and torque at stator frequency w1,
         max voltage  and current"""
         if with_tmech:
@@ -553,29 +580,33 @@ class PmRelMachine(object):
             return (iq, id, torque)
         # Field weaking range
         imax = betai1(iq, id)[1]
-        iq, id, tq = self.iqd_imax_umax(imax, w1, u1max, torque,
+        iq, id, tq = self.iqd_imax_umax(imax, w1, u1max, torque, with_mtpa=with_mtpa,
                                         with_mtpv=False, with_tmech=with_tmech)
         if log:
             log((iq, id, tq))
         return iq, id, tq
 
-    def iqd_imax_umax(self, i1max, w1, u1max, torque, with_mtpv=True, with_tmech=True):
+    def iqd_imax_umax(self, i1max, w1, u1max, torque, with_mtpv=True, with_tmech=True, with_mtpa=True):
         """return d-q current and shaft torque at stator frequency and max voltage
         and max current (for motor operation if maxtorque else generator operation)"""
-
         if torque > 0:
+            sign=-1
             # -pi/2 --> 0
             b0, b1 = max(-np.pi/2, self.betarange[0]), 0
             if max(self.betarange) < b1:
                 raise ValueError(
                     f"invalid betarange for maxtorque>0: {self.betarange}")
         else:
+            sign=1
             # -pi/2 --> -pi
             b0, b1 = -np.pi/2, max(-np.pi, self.betarange[0])
             if min(self.betarange) > b0:
                 raise ValueError(
                     f"invalid betarange for maxtorque<0: {self.betarange}")
-
+        if with_mtpa:
+            iq, id, _ = self.mtpa(i1max)
+        else:
+            iq, id = iqd(0, i1max)
         deps = 1e-6
         kmax = 100
 
@@ -678,7 +709,6 @@ class PmRelMachine(object):
                                  i1max - betai1(*iqd)[1]})
         res = so.minimize(lambda iqd: sign*self.torque_iqd(*iqd), i0,
                           method='SLSQP', constraints=constraints)
-        #logger.info("mtpv %s", res)
         if res['success']:
             return res.x[0], res.x[1], sign*res.fun
         raise ValueError(f"mtpv w1={w1} u1={u1} i0 {i0} iqd0 {iqd0} maxtorque={maxtorque} res: {res['message']}")
@@ -703,7 +733,6 @@ class PmRelMachine(object):
         res = so.minimize(lambda iqd: sign*self.tmech_iqd(*iqd, n), i0,
                           method='SLSQP',
                           constraints=constraints)
-        #logger.info("mtpv_torque %s", res)
         if res['success']:
             return res.x[0], res.x[1], sign*res.fun
         #logger.warning("w1=%.1f u1=%.1f maxtorque=%s %s: %s", w1, u1, maxtorque, res.x, res.message)
@@ -758,11 +787,9 @@ class PmRelMachine(object):
         returns list of speed limit for each interval
         calculates with friction and windage losses if with_tmech=True
         """
-        if with_tmech:
-            w1type, T = self.w1_imax_umax(i1max, u1max)
-        else:
-            iq, id, T = self.mtpa(i1max)
-            w1type = self.w1_umax(u1max, iq, id)
+        w1type, T = self.w1_imax_umax(i1max, u1max,
+                                      with_tmech=with_tmech,
+                                      with_mtpa=with_mtpa)
         Pmax = w1type/self.p*T
         # check max speed:
         sp = speedmax
@@ -776,7 +803,7 @@ class PmRelMachine(object):
                 else:
                     iq, id, tq = self.iqd_imax_umax(
                         i1max, w1max, u1max,
-                        T, with_mtpv=False,
+                        T, with_mtpv=False, with_mtpa=with_mtpa,
                         with_tmech=with_tmech)
                 break
             except ValueError:
@@ -804,7 +831,8 @@ class PmRelMachine(object):
                         with_mtpa, with_tmech)[:2]
                 else:
                     iq, id = self.iqd_imax_umax(i1max, wx, u1max,
-                                                T, with_mtpv=False)[:2]
+                                                T, with_mtpa=with_mtpa,
+                                                with_mtpv=False)[:2]
                 i1 = betai1(iq, id)[1]
                 try:
                     if with_tmech:
@@ -957,42 +985,53 @@ class PmRelMachine(object):
         r = dict(id=[], iq=[], uq=[], ud=[], u1=[], i1=[], T=[],
                  beta=[], gamma=[], phi=[], cosphi=[], pmech=[], n=[], type_op=[])
 
+        i1max = 0
         if kwargs.get('i1max', 0):
-            w1type, T = self.w1_imax_umax(kwargs['i1max'], u1max)
+            i1max = kwargs['i1max']
+            w1, Tf = self.w1_imax_umax(i1max, u1max,
+                                      with_mtpa=with_mtpa,
+                                      with_tmech=with_tmech)
+            if with_mtpa:
+                iq, id, T = self.mtpa(i1max)
+            else:
+                iq, id = iqd(0, i1max)
 
         if np.isscalar(T):
-            tmax = self.torquemax(self.i1range[1])
-            tmin = 0
-            if self.betarange[0] < -np.pi/2:
-                tmin = -self.torquemin(self.i1range[1])
-            if tmin > T or T > tmax:
-                if with_torque_corr:
-                    Torig = T
-                    if T > 0:
-                        T = np.floor(tmax)
+            if i1max == 0:
+                tmax = self.torquemax(self.i1range[1])
+                tmin = 0
+                if self.betarange[0] < -np.pi/2:
+                    tmin = -self.torquemin(self.i1range[1])
+                if tmin > T or T > tmax:
+                    if with_torque_corr:
+                        Torig = T
+                        if T > 0:
+                            T = np.floor(tmax)
+                        else:
+                            T = np.ceil(tmin)
+                        logger.warning("corrected torque: %f -> %f Nm",
+                                       Torig, T)
                     else:
-                        T = np.ceil(tmin)
-                    logger.warning("corrected torque: %f -> %f Nm",
-                                   Torig, T)
+                        raise ValueError(
+                            f"torque {T} Nm out of range ({tmin:.1f}, {tmax:.1f} Nm)")
+
+                if with_mtpa:
+                    iq, id = self.iqd_torque(T)
+                    i1max = betai1(iq, id)[1]
+                    if T < 0:
+                        i1max = -i1max
                 else:
-                    raise ValueError(
-                        f"torque {T} Nm out of range ({tmin:.1f}, {tmax:.1f} Nm)")
+                    i1max = self.i1_torque(T, 0)
+                    iq, id = iqd(0, i1max)
 
-            if with_mtpa:
-                iq, id = self.iqd_torque(T)
-                i1max = betai1(iq, id)[1]
-                if T < 0:
-                    i1max = -i1max
-            else:
-                i1max = self.i1_torque(T, 0)
-                iq, id = iqd(0, i1max)
+                if with_tmech:
+                    w1, Tf = self.w1_imax_umax(i1max, u1max, with_mtpa=with_mtpa,
+                                               with_tmech=with_tmech)
+                else:
+                    iq, id = self.iqd_torque(T)
+                    Tf = T
+                    w1 = self.w1_umax(u1max, iq, id)
 
-            if with_tmech:
-                w1, Tf = self.w1_imax_umax(i1max, u1max)
-            else:
-                iq, id = self.iqd_torque(T)
-                Tf = T
-                w1 = self.w1_umax(u1max, iq, id)
             assert w1>0, f"Invalid values u1 {u1max}, T {T}, iq: {iq} id: {id}"
             n1 = w1/2/np.pi/self.p
             r['n_type'] = n1
@@ -1030,11 +1069,7 @@ class PmRelMachine(object):
             logger.info("sample intervals %s", nstab)
             for nx in np.linspace(0, n1, nstab[0]):
                 if with_tmech:
-                    iq, id = self.iqd_tmech(Tf, nx, (iq, id),
-                                            with_mtpa or nx == n1)[:2]
-                else:
-                    iq, id = self.iqd_torque(Tf, (iq, id),
-                                             with_mtpa or nx == n1)[:2]
+                    T = self.tmech_iqd(iq, id, nx)
                 r['id'].append(id)
                 r['iq'].append(iq)
                 r['n'].append(nx)
@@ -1042,6 +1077,7 @@ class PmRelMachine(object):
 
             r['type_op'] = list(betai1(iq, id))
             Pmax = 2*np.pi*n1*Tf
+            tq = Tf
             for ns, nu, iv in zip(nstab[1:], speedrange[2:], interv):
                 # find id, iq, torque in fieldweakening range
                 if ns > 0:
@@ -1062,8 +1098,9 @@ class PmRelMachine(object):
                                 else:
                                     iq, id, tq = self.iqd_imax_umax(
                                         i1max, w1, u1max,
-                                        Tf, with_tmech=with_tmech,
-                                        with_mtpv=with_mtpv)
+                                        tq, with_tmech=with_tmech,
+                                        with_mtpv=with_mtpv,
+                                        with_mtpa=with_mtpa)
                             else:
                                 if with_tmech:
                                     iq, id, tq = self.mtpv_tmech(w1, u1max,
@@ -1452,6 +1489,7 @@ class PmRelMachinePsidq(PmRelMachine):
                 if k in pfe}
         except KeyError as e:
             logger.warning("loss map missing: %s", e)
+
             pass
 
     def psi(self, iq, id):

femagtools/parstudy.py

@@ -179,15 +179,21 @@ class ParameterStudy(object):
         extra_result_files = []
         if simulation.get('airgap_induc', False):
             extra_result_files.append('bag.dat')
-        simulation['arm_length'] = model.lfe
-        simulation['lfe'] = model.lfe
+        try:
+            simulation['arm_length'] = model.lfe
+            simulation['lfe'] = model.lfe
+        except AttributeError:
+            pass
         simulation['move_action'] = model.move_action
         simulation['phi_start'] = 0.0
         try:
             simulation['range_phi'] = 720/model.get('poles')
         except AttributeError: #  if dxf or pure fsl model
             simulation['range_phi'] = 0.0
-        simulation.update(model.winding)
+        try:
+            simulation.update(model.winding)
+        except AttributeError:
+            pass
         fea = femagtools.model.FeaModel(simulation)
 
         prob = femagtools.moproblem.FemagMoProblem(decision_vars,
@@ -206,11 +212,11 @@ class ParameterStudy(object):
                     except:
                         pass
             for k in ('num_slots', 'num_slots_gen'):
-                if k not in machine['stator']:
-                    try:
-                        machine['stator'][k] = model.stator[k]
-                    except:
-                        pass
+                try:
+                    if k not in machine['stator']:
+                            machine['stator'][k] = model.stator[k]
+                except KeyError:
+                    pass
         job = engine.create_job(self.femag.workdir)
         if self.femag.cmd:
             engine.cmd = [self.femag.cmd]
@@ -226,7 +232,10 @@ class ParameterStudy(object):
             fea.poc.pole_pitch = 2*360/model.get('poles')
             fea.pocfilename = fea.poc.filename()
         if not hasattr(fea, 'pocfilename'):
-            fea.pocfilename = f"{model.name}_{model.get('poles')}p.poc"
+            try:
+                fea.pocfilename = f"{model.name}_{model.get('poles')}p.poc"
+            except AttributeError:
+                logger.warning("Missing number of poles")
         elapsedTime = 0
         self.bchmapper_data = []  # clear bch data
         # split x value (par_range) array in handy chunks:

femagtools/plot/bch.py

@@ -527,20 +527,36 @@ def demagnetization(demag, ax=0):
     i1 = [scale*x for x in demag['i1']]
     ax.plot(i1, demag['rr'], 'o', color='C0')
     ax.plot(i1, demag['rr'], color='C0')
-    rrmin = 0.6
+    rrmin = min(0.6, np.min(demag['rr']))
+
+    Imax = scale*abs(demag['i1max'])
+    demaglabels = [f'Imax  = {Imax:.1f} {unit}']
     if demag.get('i1c', 0):
         Icrit = scale*demag['i1c']
-        Hk = demag['Hk']
-        Tmag = demag['Tmag']
-        di = 0.05*np.max(i1)
-        rrmin = min(0.6, np.min(demag['rr']))
-        ax.plot([Icrit, Icrit], [rrmin, 1], 'k--')
-        ax.annotate(
-            f'Icrit = {Icrit:.1f}{unit}\nHk = {Hk:.1f} kA/m\nTmag={Tmag:.1f} °C',
-            xy=(Icrit, rrmin),
-            xytext=(Icrit-di, rrmin+0.1*(1-rrmin)), ha='right',
+        ax.plot([Icrit, Icrit], [rrmin, 1], 'r:')
+        ax.text(Icrit, rrmin+0.15, 'Icrit', fontfamily='monospace',
+                rotation=90, size='large', ha='right', va='bottom')
+        demaglabels.append(f'Icrit = {Icrit:.1f} {unit}')
+
+    ax.plot([Imax, Imax], [rrmin, 1], 'g:')
+    ax.text(Imax, rrmin+0.05, 'Imax', fontfamily='monospace',
+                rotation=90, size='large', ha='right', va='bottom')
+
+    Hk = demag['Hk']
+    Tmag = demag['Tmag']
+    demaglabels += [f'Hk    = {Hk:.1f} kA/m',
+                    f'Tmag  = {Tmag:.1f} °C']
+
+    ax.text(0, rrmin+0.05,
+            '\n'.join(demaglabels),
+                fontfamily='monospace',
+            ha='left', va='bottom', size='large',
             bbox={'facecolor': 'white',
                   'edgecolor': 'white'})
+
+    #ax.annotate('Imax', xy=(Imax, demag['rr_i1max']), ha='center', va='bottom',
+    #               xytext=(Imax, demag['rr_i1max']-0.1), rotation=90,
+    #        arrowprops=dict(facecolor='green', edgecolor='green', shrink=0.05))
     ax.set_ylim([rrmin, 1.01])
     ax.set_ylabel('Rel. Remanence')
     ax.set_xlabel(f'Phase Current / {unit}')

femagtools/shortcircuit.py

@@ -106,16 +106,19 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
                 encoding='latin1', errors='ignore'))
             bchsc.scData['demag'] = bchsc.demag
             if simulation.get('sim_demagn', 0):
-                d = {'displ': [d['displ']
+                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]}
-                simulation['i1max'] = bchsc.scData['iks']
+                i1max = bchsc.scData['iks']
+                if dd['displ']:
+                    phi = dd['displ'][0]/180*np.pi
                 bchsc.scData['demag'] = demag(
-                    femag, machine, simulation, engine)
-                bchsc.scData['demag'].update(d)
+                    femag, machine, simulation,
+                    i1max, phi, engine)
+                bchsc.scData['demag'].update(dd)
             scdata = bchsc.scData
             #for w in bch.flux:
             #    try:
@@ -129,13 +132,13 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
     if simulation.get('sc_type', 3) == 2:
         if 'i1max' not in simulation:
             # just a wild guess
-            simulation['i1max'] = 4.5*bch.machine['i1']
+            simulation['i1max'] = 5*bch.machine['i1']
         logger.info("2phase short circuit simulation i1max = %.0f",
                     simulation['i1max'])
         scdata = shortcircuit_2phase(femag, machine, simulation, engine)
 
     else:
-        logger.warning("Empty shortcircuit results for type %d",
+        logger.warning("Empty shortcircuit results for type %s",
                        simulation.get('sc_type', 'unknown'))
     # must reset calcmode
     if calcmode:
@@ -161,12 +164,13 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
     num_cur_steps = 4
     i1 = np.linspace(0, i1max, num_cur_steps)
     i1vec = np.concat((-i1[::-1], i1[1:]))
-    num_par_wdgs = machine['winding'].get('num_par_wdgs', 1)
     flux_sim = {
         'calculationMode': 'psi-torq-rot',
         'i1max': i1max,
         'curvec': [],
-        'num_par_wdgs': num_par_wdgs}
+        'magntemp': simulation['magn_temp'],
+        'fc_radius': simulation['fc_radius'],
+        'num_par_wdgs': simulation['num_par_wdgs']}
 
     if engine:
         parstudy = _parstudy_list(femag, sc_result_func)
@@ -304,6 +308,11 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
     logger.info("Torque %.1f %.1f %.1f (dphi %.4f)",
                 tp[1], tv[1], tc[1], dphi)
 
+    # rotor position at maximum current:
+    trot = min(iav[0], iap[0])
+    phi = wm*trot + phi0
+    logger.info("phi %.1f")
+
     scData = {
         'ia': ia.tolist(),
         'ib': (-ia).tolist(),
@@ -316,63 +325,52 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
         'iks': iap[1] if iap[1] > abs(iav[1]) else iav[1],
         'tks': tp[1] if tp[1] > abs(tv[1]) else tv[1]
     }
-    scData['peakWindingCurrents'] = [scData['iks'],
-                                     -scData['iks'], 0]
+    scData['peakWindingCurrents'] = [float(scData['iks']),
+                                     -float(scData['iks']), 0]
     if simulation.get('sim_demagn', 0):
-        scData['demag'] = demag(femag, machine, simulation, engine)
+        i1max = iap[1] if iap[1] > abs(iav[1]) else iav[1]
+        scData['demag'] = demag(femag, machine, simulation,
+                                i1max, phi, engine)
     return scData
 
-def dm_result_func(task):
-    basedir = pathlib.Path(task.directory)
-    i1rr = []
-    for f in sorted(basedir.glob('psi-torq-rem-rot-*.dat')):
-        ptr = np.loadtxt(f)
-        i1rr.append((np.max(ptr.T[1:4]), np.min(ptr.T[-1])))
-    return i1rr
-
-def demag(femag, machine, simulation, engine=0):
+def demag(femag, machine, simulation, i1max, phi, engine=0):
     """demag simulation using psi-torq-rem-rot"""
     logger.info("Demagnetization processing")
-    i1max = simulation['i1max']
-    i1min = simulation.get('i1min', i1max/4)
+    i1min = simulation.get('i1min', abs(i1max/3))
     num_steps = 7
-    b = (i1min-i1max)/np.log(i1min/i1max)
-    a = i1max/b
-    i1tab = [b*(a+np.log(x))
-             for x in np.linspace(i1min/i1max, 1,
-                                  num_steps)]
+    b = (i1min-abs(i1max))/np.log(i1min/abs(i1max))
+    a = abs(i1max)/b
+    xtab = np.linspace(i1min/abs(i1max),
+                       1+2*(1-i1min/abs(i1max))/(num_steps-1), num_steps+2)
+    i1tab = b*(a+np.log(xtab))
 
     if simulation.get('sc_type', 3) == 3:
         curvec = [[-a/2, a, -a/2] for a in i1tab]
     else:
-        curvec = [[a, -a, 0] for a in i1tab]
+        if i1max > 0:
+            curvec = [[a, -a, 0] for a in i1tab]
+        else:
+            curvec = [[-a, a, 0] for a in i1tab]
     simulation.update({
-        'calculationMode': 'psi-torq-rem-rot',
+        'calculationMode': 'psi-torq-rem',
+        'phi': phi,
+        'magntemp': simulation['Tmag'],
         'curvec': curvec})
-    if engine:
-        parstudy = _parstudy_list(femag, dm_result_func)
-        parvardef = {
-            "decision_vars": [
-                {"values": curvec, "name": "curvec"}]
-        }
-        results = parstudy(parvardef, machine, simulation, engine)
-        i1rr = np.vstack(
-            ((0, 1),
-             np.array(results['f']).reshape((-1, 2))))
-    else:
-        class Task:
-            def __init__(self, workdir):
-                self.directory = workdir
-        _ = femag(machine, simulation)
-        i1rr = np.vstack(
-            [(0, 1), dm_result_func(Task(femag.workdir))])
-    i1, rr = np.array(i1rr).T
+    _ = femag(machine, simulation)
+
+    ptr = np.loadtxt(femag.workdir / "psi-torq-rem.dat")
+    i1 = np.concat(([0], np.max(ptr[:,1:4], axis=1)))
+    rr = np.concat(([1], ptr[:,-1]))
     dmag = {'Hk': simulation['Hk'],
             'Tmag': simulation['Tmag'],
             'i1': i1.tolist(),
+            'i1max': float(np.abs(i1max)),
             'rr': rr.tolist()}
     # critical current
     if np.min(rr) < 0.99:
-        k = np.where(rr < 0.99)[0][0]
-        dmag['i1c'] = i1[k]
+        k = np.where(np.diff(dmag['rr'])<-1e-3)[0][0]+1
+        dmag['i1c'] = float(i1[k])
+        if abs(i1max) < i1[-1]:
+            rrf = make_interp_spline(i1, rr)
+            dmag['rr_i1max'] = float(rrf(abs(i1max)))
     return dmag

femagtools/templates/plots.mako

@@ -1,4 +1,3 @@
--- Plots
 % for p in model.get('plots', []):
 % if not isinstance(p, str):
 % if p[0] == 'field_lines':

femagtools/templates/psi-torq-rem.mako

@@ -0,0 +1,112 @@
+-- calculate flux linkages, torque, and rel remanence (magstatic mode)
+--
+-- model:
+--    Hk (kA/m) knee point field strength
+--    curvec (A) phase current amplitude samples (list of [ía, ib, ic])
+--    num_par_wdgs (number of parallel winding groups, default 1)
+--    fc_radius (m) radius of airgap center
+--
+-- creates file psi-torq-rem.dat in current directory with columns:
+--  displ curr1 curr2 curr3 psi1 psi2 psi3 torq rrem
+
+<%include file="magnet-data.mako"/>
+
+function dmg(ek, Br, alfam, murm, Bd, Bq, Hd, Hq, alfahm, Hk)
+   if Hd < Hk then
+      muem = murm*4*math.pi*1e-7
+      Brn = Bd - Hk*1e3*muem
+      if Br < 1e-5 then
+         Brn = 1e-5
+      end
+      return Brn, alfam, 1
+   end
+   return Br, alfam, 1
+end
+
+function calc_flux_torq_rem(curvec)
+    for k=1,3 do
+      def_curr_wdg(k, curvec[k]/a, 0)
+    end
+
+    dRR = 0
+    RR = 0
+    maxit=m.num_nonl_it
+    maxcop=m.error_perm -- err_perm in %
+    permode='restore'
+    repeat
+       calc_field_single({
+        maxit=maxit, maxcop=maxcop, -- err_perm in %
+        permode=permode})
+       if(maxit > 1) then
+          maxit = 1
+          permode='actual'
+          maxcop = 0.05
+       end
+       stat, RR, dRR = calc_demag(5, Hk)
+       --printf("%g %g", RR, dRR)
+    until math.abs(dRR) < 1e-5
+
+    psi = {}
+    for k=1,3 do
+      psir, psii = flux_winding_wk(k)
+      psi[k] = {ksym*psir/a*m.arm_length, ksym*psii/a*m.arm_length}
+    end
+
+    fr, ft, tq, fx, fy = force_torque()
+
+  return psi, tq, RR
+end
+%if model.get('fc_radius', 0):
+if m.fc_radius == nil then
+  m.fc_radius = ${model['fc_radius']*1e3}
+end
+%endif
+%if type(model.get('curvec')[0]) is list:
+curvec = {${','.join(['{'+','.join([str(x) for x in y])+'}' for y in model['curvec']])}} -- A
+%else:
+curvec = {{${','.join([str(x) for x in model['curvec']])}}} -- A
+%endif
+a=${model.get('num_par_wdgs', 1)}   -- parallel branches
+
+ksym = m.num_poles/m.npols_gen
+
+-- HcB = Brem*tempcoefbr*(magn_temp-20)+1)/muerel/12.565e-7
+-- Hcmin = HcJ*tempcoefhc*(magn_temp-20.0)+1)/HcB*1e2 -- limit of demagnetization in
+Hk = ${model.get('Hk', -999)}
+
+phi = ${model.get('phi', 0)}*180/math.pi
+-- initialize rotate
+rotate({
+    airgap = m.fc_radius,    -- air gap radius
+    region = "inside",       -- region to rotate
+    mode   = "save"         -- save initial model state
+})
+
+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])
+
+    file_psi:write(string.format("%g ", phi))
+    for k=1, 3 do
+      file_psi:write(string.format("%g ", curvec[i][k]))
+    end
+    for k=1, 3 do
+      file_psi:write(string.format("%g ", psi[k][1]))
+    end
+    file_psi:write(string.format("%g ", tq))
+    file_psi:write(string.format("%g ", rr))
+    file_psi:write("\n")
+
+% if model.get('plots', []):
+  if i == #curvec-2 then
+<%include file="plots.mako"/>
+  end
+% endif
+end
+
+  rotate({mode = "reset"})  -- restore the initial state (discard any changes)
+  file_psi:close()

femagtools/templates/psi-torq-rot.mako

@@ -7,6 +7,8 @@
 -- creates file psi-torq-rot.dat in current directory with columns:
 --  displ curr1 curr2 curr3 psi1 psi2 psi3 torq
 --
+<%include file="magnet-data.mako"/>
+
 function gcd(a, b)
 	return b==0 and a or gcd(b,a%b)
 end
@@ -69,6 +71,11 @@ dphi = 360//gcd(Q1, p)/nrot
 print(string.format(" rotation steps: %d  current steps: %d\n", nrot, #curvec))
 
 phi = 0
+%if model.get('fc_radius', 0):
+if m.fc_radius == nil then
+  m.fc_radius = ${model['fc_radius']*1e3}
+end
+%endif
 -- initialize rotate
 rotate({
     airgap = m.fc_radius,    -- air gap radius

femagtools/windings.py

@@ -70,46 +70,64 @@ def end_wdg_length_round_wires(layers, Rp, Rb, r_wire, h, coil_span, Q, bore_dia
     l_ew = 2*h + l + z + (Rb + r_wire)*(np.pi - 2)
     return l_ew, h, Rp, Rb
 
-def end_wdg_hairpin_check(alpha, h, dmin, l_h, wire_w, tooth_wmin):
+def end_wdg_hairpin_check(alpha, h, dmin, l_h, wire_w, tooth_wmin, h_conn):
     alpha = alpha*np.pi/180     # ensure alpha is in radians
+    dmin_new = 0
+    alpha_new = 0
+    h_new = 0
+
+    if dmin < 0.0015:
+        dmin = 0.0015
+    if h_conn < 0.005:
+        h_conn = 0.005
+
     if alpha == 0 and h == 0: # end wdg parameters not set
-        alpha = np.arcsin((dmin + wire_w)/(tooth_wmin + wire_w))
-        h = np.tan(alpha)*l_h/2
-    elif alpha == 0 and h > 0: # imposed end wdg height
-        alpha = np.arctan(h/l_h)
-        dmin = np.sin(alpha)*(tooth_wmin + wire_w) - wire_w
-        if dmin < 0.0015: # imposed end wdg height is not feasible - calculate min end wdg parameters
-            dmin = 0.0015
-            alpha = np.arcsin((dmin + wire_w)/(tooth_wmin + wire_w))
-            h = np.tan(alpha)*l_h/2
+        alpha_new = np.arcsin((dmin + wire_w)/(tooth_wmin + wire_w))
+        h_new = np.tan(alpha_new)*l_h/2
+
+    elif h > 0: # imposed end wdg height
+        alpha_new = np.arctan(h/l_h)
+        dmin_new = np.sin(alpha_new)*(tooth_wmin + wire_w) - wire_w
+        if dmin_new < dmin: # imposed end wdg height is not feasible - calculate min end wdg parameters
+            dmin_new = dmin
+            alpha_new = np.arcsin((dmin_new + wire_w)/(tooth_wmin + wire_w))
+            h_new = np.tan(alpha_new)*l_h/2
+
     elif alpha > 0: # imposed end wdg angle
-        dmin = np.sin(alpha)*(tooth_wmin + wire_w) - wire_w
-        if dmin < 0.0015: # imposed end wdg angle is not feasible - calculate min end wdg parameters
-            dmin = 0.0015
-            alpha = np.arcsin((dmin + wire_w)/(tooth_wmin + wire_w))
-            h = np.tan(alpha)*l_h/2
-    return h, alpha, dmin
+        dmin_new = np.sin(alpha)*(tooth_wmin + wire_w) - wire_w
+        if dmin_new < dmin: # imposed end wdg angle is not feasible - calculate min end wdg parameters
+            dmin_new = dmin
+            alpha_new = np.arcsin((dmin_new + wire_w)/(tooth_wmin + wire_w))
+            h_new = np.tan(alpha_new)*l_h/2
+
+    if dmin_new > dmin:
+        dmin = dmin_new
+    if alpha_new > alpha:
+        alpha = alpha_new
+    if h_new > h:
+        h = h_new
+
+    return h, alpha, dmin, h_conn
 
 def end_wdg_length_hairpins(wire_h, wire_w, wire_th, wire_gap,
-                                 layers, coil_pitch, Q, bore_diam, slot_h, slot_w,
+                                 layers, coil_pitch, Q, bore_diam, slot_w, slot_h,
                                  h_bent=0, h_welded=0, h_conn=0.005, alpha_bent=0, alpha_welded=0, dmin=0.0015): # needs to be validated
     '''return end wdg length of single pin for bent and welded side, average end wdg length,
      bent and welded side end wdg heights, bending angles and min distances between pins'''
 
     R_avg = bore_diam/2 + wire_th + layers/2*(wire_h + wire_gap) + wire_h/2
-    l_h = R_avg/2*coil_pitch/Q*np.pi*(bore_diam + wire_th + slot_h)
+    l_h = R_avg*coil_pitch/Q*2*np.pi
     tooth_wmin = (bore_diam + 2*wire_th)*np.pi/Q - slot_w
 
-    h_bent, alpha_bent, dmin = end_wdg_hairpin_check(alpha_bent, h_bent, dmin, l_h, wire_w, tooth_wmin)
-
+    h_bent, alpha_bent, dmin, h_conn = end_wdg_hairpin_check(alpha_bent, h_bent, dmin, l_h, wire_w, tooth_wmin, h_conn)
     h_welded = h_welded - h_conn if h_welded - h_conn > 0 else 0
-    h_welded, alpha_welded, dmin = end_wdg_hairpin_check(alpha_welded, h_welded, dmin, l_h, wire_w, tooth_wmin)
+    h_welded, alpha_welded, dmin, h_conn = end_wdg_hairpin_check(alpha_welded, h_welded, dmin, l_h, wire_w, tooth_wmin, h_conn)
 
-    l_bent = 2*(0.002 + wire_w/2*alpha_bent + wire_w*(np.pi/2 - alpha_bent) + np.sqrt((l_h/2)**2 + h_bent**2))
-    l_welded = 2*(0.002 + wire_w/2*alpha_bent + wire_w*(np.pi/2 - alpha_bent) + np.sqrt((l_h/2)**2 + h_welded**2)) + h_conn
+    l_bent = 2*(0.003 + wire_w/2*alpha_bent + wire_w*(np.pi/2 - alpha_bent) + np.sqrt((l_h/2)**2 + h_bent**2))
+    l_welded = 2*(0.003 + wire_w/2*alpha_bent + wire_w*(np.pi/2 - alpha_bent) + np.sqrt((l_h/2)**2 + h_welded**2)) + h_conn
     l_ew = (l_bent + l_welded)/2
     h_welded = h_welded + h_conn
-    return l_bent, l_welded, l_ew, h_bent, h_welded, alpha_bent*180/np.pi, alpha_welded*180/np.pi, dmin
+    return l_bent, l_welded, l_ew, h_bent, h_welded, h_conn, alpha_bent*180/np.pi, alpha_welded*180/np.pi, dmin
 
 
 class Winding(object):

{femagtools-1.8.10.dist-info → femagtools-1.8.12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: femagtools
-Version: 1.8.10
+Version: 1.8.12
 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.10.dist-info → femagtools-1.8.12.dist-info}/RECORD

@@ -1,4 +1,4 @@
-femagtools/__init__.py,sha256=ZCll3GyhwvdCbSO2mQZWjanTN5Pz5tVaggny3TCglNk,1601
+femagtools/__init__.py,sha256=wRK12H26MLJW_1cDk2ngqCP1fJGYZOWzt-2ugf0c9ao,1601
 femagtools/airgap.py,sha256=hELJXe52yUw82JwZ1tGUXUtRhMG2_WSUBVeGkTZSAM8,1900
 femagtools/amazon.py,sha256=O1ICuv21XDAJi1qK1Sigs2TdS6hDZP19OzvmE2t76wU,12069
 femagtools/amela.py,sha256=2q-Xsj6i6nQ3iKheBR1vQ4FulJfF1i-L8w3a3U8GYWo,4362
@@ -17,17 +17,17 @@ femagtools/ecloss.py,sha256=nES8mtXNFitmxDvKL5o39hZl6qu-HfR6kUh9eBA9zxQ,34660
 femagtools/erg.py,sha256=IXKq76P9qLt_ssNOP78v8Qizk3J2Zg80yaKDSjzwoJE,1224
 femagtools/femag.py,sha256=ScrZ9gbWQIy4eIhF0Wmi41lSFm7-WRtiLcJOvkITcHo,44864
 femagtools/forcedens.py,sha256=7NNv75Vg9vQ_fy8W4kM2rlSO970zaSmeurhPmdAxsOU,8485
-femagtools/fsl.py,sha256=e6qeGEUdbupwDXMPNGwpSxdRENjyWrUuXEFXGIoXavE,37187
+femagtools/fsl.py,sha256=J1V1Kr-PZpWbLegYMAvgfUabj1WZOji_-JR9mlf23gg,37043
 femagtools/getset.py,sha256=yJ6Em35DeWK7WNZW0qjjS5s7LUkVh5mbgxF59HHm5FM,3017
 femagtools/gmsh.py,sha256=IKhNiviIBji4cMxAhxaYXNqBRMNAPSKsBGdnGyxkyQw,3903
 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=6wDyJmMMVncjOt8ObnFyvYxdpRTUc93IE6bOfWmu6u8,66067
+femagtools/isa7.py,sha256=HqTQmbOLmLi75ytXpkryeYiXqUChi07mBUNYYj9xOjk,66365
 femagtools/jhb.py,sha256=stJxkmzHpfUIBVcFw7jWbV5KN9_EFqzOCgacyhUqWvM,1779
 femagtools/job.py,sha256=sIRVXsyoupfRXqGsWyOHMetcKlWIyggxfVURjM8aD54,11322
-femagtools/leakinduc.py,sha256=TMCz0DNbVwRPAYIe-kt9Ttu4aO-HhMZSIP_MTTLaSDo,2267
+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
@@ -40,16 +40,16 @@ femagtools/nc.py,sha256=sKfFaeT8hPVUCb1axPIwfUVxuUsnrHygdfqiHv7G_YA,15216
 femagtools/netlist.py,sha256=CSCl8setLZ_L8DCnNWaNA3-wLe1yo-fmzARZoVvYfaA,2052
 femagtools/ntib.py,sha256=76g1ZO3Fq_kN-HTMBvaKvJmMMlJMyEPFeNAcJPq3w7Y,3099
 femagtools/opt.py,sha256=wBU0yh3hZlNti_zfIvtKcPg1EJrnE3I1BqmVxLGWixU,8753
-femagtools/parstudy.py,sha256=WY1LxvN44LBqhmZb2dnNO5lVRW3oNyRiKmyi6QxdmqU,19792
+femagtools/parstudy.py,sha256=kYUUX7wGggt5FEkH2jChl_BhAmKqBACCFYF_LN5mHeA,20045
 femagtools/poc.py,sha256=yPWmpi8Q2g7NmpAi2YV5ezyo0VUj67EK0tcX2wikerw,7207
 femagtools/semi_fea.py,sha256=WZtYKrzhDruETyuEW2kpiNp9OaA7Hheq3qJiAIYtsjg,3475
-femagtools/shortcircuit.py,sha256=9LjnX4z3Kt_DI7DO_h-ivZqxvPt8eAnkJ8_RIFB_q-s,13936
+femagtools/shortcircuit.py,sha256=B1gfxItKLv2qDgdHQkDWaSAAHsNwXdDD7Hu8mysIekY,14001
 femagtools/tks.py,sha256=mDi45S5go9-jwALh6rS9RWPoOFBORZm0-XL4ECjSf_8,7531
 femagtools/ts.py,sha256=x9aCMVASjdBZuyI2pJGMyi1dveGFd_pWQ20cZ-l_moc,47216
 femagtools/utils.py,sha256=dJkQ5xsoVMzSEB5-2hEiwe2of9mLmsDo8nkrnSN-gPE,1643
 femagtools/vbf.py,sha256=9XGfhftmD9carU8ByQ5DwqoR4daq5mJ39eMqruwml0Q,2444
 femagtools/vtu.py,sha256=Sf83dHIfCKY2km-MIUHKKoj-JKN4PDX7kkPLZXyIYY4,10723
-femagtools/windings.py,sha256=Jk1FGLnKMltDct_plcaFW-NMUE6YFrP57LtJrdw1Un0,27140
+femagtools/windings.py,sha256=p7BkIbi8mMc_CmWqAjOZNKz1-GlQb4kON4rWhvlARf8,27498
 femagtools/zmq.py,sha256=HY8U7dxXkgE48151nvLcnLPa8OFBZcZTrB2XcjBc0Y4,9413
 femagtools/dxfsl/__init__.py,sha256=MywcCdpKPKs4qJBJJgeDsikJFJ2P48dbTuNk303f5pM,76
 femagtools/dxfsl/area.py,sha256=CpTMRBF8_AJmJMkkn-LgRv27U5xJ5Ohhd2ppRvESPNU,69757
@@ -71,10 +71,10 @@ femagtools/dxfsl/shape.py,sha256=uQqbgXIA2_KP2XRdhCfVfGWjcjwzhJ5t9RhiqR9R98c,616
 femagtools/dxfsl/svgparser.py,sha256=RY2TU9MK6gOaNmI6w6RNqcw7H9YGmK-NUwvdylKBcsE,3763
 femagtools/dxfsl/symmetry.py,sha256=dXfZVIqT49nbMirY5YVaRPi8kNB8reaiq-eIbhw1Z54,43936
 femagtools/machine/__init__.py,sha256=B7yeRZzf29NWCWy8C8iJFdTr9bszAoMRcVEpblhCeg4,7256
-femagtools/machine/afpm.py,sha256=X3tGpPytPaVQPh5PNMLZRyLVW9IHIoXZDB6DiNGvu-s,40097
-femagtools/machine/effloss.py,sha256=wVsXqMni74IopYb6SHNWjEh-_6rjeLNNiWMB29ar0ms,14898
+femagtools/machine/afpm.py,sha256=ZkYk-acfmwV2ebhU8BUE6dKYkDrCR8UKp1plxEdZ4v8,40223
+femagtools/machine/effloss.py,sha256=6mPm4Y_3lVXc1hOyCgTfRkGK3IAeC8gSxNnbSPL7or8,15508
 femagtools/machine/im.py,sha256=isMSoCnIk4Hj47MwBNP5PW7a2rI-7N35A9zHGOSl43s,38111
-femagtools/machine/pm.py,sha256=C4vDdPIsIRUKtzY3b1RNT1v37p1uP3pMUduftNejcPc,68129
+femagtools/machine/pm.py,sha256=PTzQDIjHzKSoO2WT1jYH5cvCUCdAkmlmCfd2N35EbIs,69967
 femagtools/machine/sizing.py,sha256=6IUSdp6HNGHlSaWMy0mjzLGxp3UtxFLfdzQ_4MYx7TI,30069
 femagtools/machine/sm.py,sha256=SLaSuGJ8zXIFq6uBR2iu4uLXyWJZjA3iHAaTC8Jm-gw,39117
 femagtools/machine/utils.py,sha256=25QNxP8lp31W7kB-gcIA1Vd_9UcYlxrahqZ-k3ALU_s,20985
@@ -86,7 +86,7 @@ femagtools/moo/test/AlgorithmTest.py,sha256=KzR1og4bu6NOE61DDKjEMTQdsysmho4LCYmJ
 femagtools/moo/test/PopulationTest.py,sha256=lG9NeWo0xrslfQRa4tgy1Nj23VJMFIlg_vQ9KUBYnRA,5529
 femagtools/moo/test/ProblemTest.py,sha256=r5XEfY4LPscDb35TxxPd0lbP3nUmL6_G6vrRo1I3RSg,505
 femagtools/plot/__init__.py,sha256=LFrHy_9L6FxJqhYND2z1534s3ebPXkfXVagFeNA1wWk,978
-femagtools/plot/bch.py,sha256=C054GIbgghiyyuwiDQw-ikmUlBZVWAYT3zSJ_T7rW_I,33397
+femagtools/plot/bch.py,sha256=c2zSrtUyQWeKoxcJPGsuNvQ59veyXlvD-Fu4UBdmAyU,34078
 femagtools/plot/char.py,sha256=xv4cNOTorK-fy7eUFhmyR-013TFI2A2999xXKgL2AnA,12469
 femagtools/plot/fieldlines.py,sha256=_7ykKhnQLeS4fz34pnzovH1gIhcUSKJ3gl1GUgWYix8,1137
 femagtools/plot/fluxdens.py,sha256=NlexRJ3f_8CgKoWrV82ZIsAXPrLhwj98uOe8_fUks7A,1082
@@ -144,14 +144,15 @@ femagtools/templates/noloadflux-rot.mako,sha256=BiAtTL0mj8ukbRiPKKyH80PpzugGIJKZ
 femagtools/templates/noloadflux.mako,sha256=vYUpZRLOAixNoBbB-Nc-Y9niPYsSUEPvBCOjw26uFdg,4661
 femagtools/templates/noloadfluxdc.mako,sha256=n3M4gNxf4Q-i7B8ft69Ism9lquRqh-pf4ET4KYwdQb0,3146
 femagtools/templates/open.mako,sha256=Zl5yvdwT5BflJIPVmReggzSrTQhepbef62EoCuw_mQg,344
-femagtools/templates/plots.mako,sha256=6xfmncVbzDiJLF6V0B6fha23H19R7P26DvcTTwzJ5A0,630
+femagtools/templates/plots.mako,sha256=2Cy4ArHE_FG6nHPJefZR3BTp9ZQD5oykYhsrzCWLyBk,621
 femagtools/templates/pm_sym_f_cur.mako,sha256=Tk4ImaSN1vPfybzersJd5AmLHnqJjWHigCeBn_Cr40U,1558
 femagtools/templates/pm_sym_fast.mako,sha256=wD_bwszJ5svPOL1AtWThbkuMyxi-wRAPpP3AMlJGwPM,2450
 femagtools/templates/pm_sym_loss.mako,sha256=FNAvi_gmTXsGylrpi7lLKPoOOcNCV1mG6rc8gnXQ8u0,1098
 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-rot.mako,sha256=e0-kJZ4mQ5w-Dd4riJkcjlJAt0STcNrVRVJfa-6cV7g,2498
+femagtools/templates/psi-torq-rem.mako,sha256=N9AcWV0_c2jvZCr-LOW6QqDC7QIbZ-cVZ2fQ_Jw61KA,3099
+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
 femagtools/templates/rotorAsyn.mako,sha256=r_gce0oic24nPdI7BmERM1sokXpC5vvm8Sm0TIPb2zI,2280
@@ -184,7 +185,7 @@ tests/test_effloss.py,sha256=-kJJNgS5c6saHXjNuhAe5GdWfr9mEYpPo8fE8OtjsNA,1142
 tests/test_erg.py,sha256=kRVzpXa6JDdbxTss18HUWKny9Dx8IMx9uGTrbQCnHwg,523
 tests/test_femag.py,sha256=l7-av3eitLm7bwTuunEmVeTspi82ifPrlz7f1boGdVI,1934
 tests/test_forcedens.py,sha256=Yzl3SAmJNkZN9dA3aLxRvwY8fKsw077Fl0iJm6zJ5Sk,536
-tests/test_fsl.py,sha256=e8NnUZLsG1Fh9fBOix_ClAl754b9lcqFp4EZR5HoDio,16623
+tests/test_fsl.py,sha256=pjgqRo5fhrKYWg-bWjPm_O6-kwVyr-ZK-oOFUgYtyso,16623
 tests/test_heat_source_network.py,sha256=TC-Gl4iy9jnMGfsY_24XjwlP-SDxP345JKVT8xRwsFo,690
 tests/test_hxy.py,sha256=pVb6ZfDhBy5-DXa3gh7RQmLFG8p5cSYB8gdGLC8kjAk,640
 tests/test_im.py,sha256=55wfCoA8_PuogI_RsC3AjUQCpR84T-HddtHuU1NxfPc,662
@@ -199,7 +200,7 @@ tests/test_mcv.py,sha256=Vv51WU3WU0AkgcSpyujMdJ2KvSdLNsks5HGtY0pWMOY,4749
 tests/test_mcvreader.py,sha256=3cgq22b_iaWLrs4WWOUNHqJREnv0YoFivNpAb4teEJs,2118
 tests/test_me.py,sha256=En00OrOhZclBO4u74q5Os0FgVP4TGFLzz99LF0QHXHA,196
 tests/test_model.py,sha256=kYjjFgZPIex3foX3skiOdD5MCcmA2JP7oDDuE9txv_U,2698
-tests/test_nc.py,sha256=aTYWF5BDakA9sYRmkSHD0oLWXcOxkVYKKUE8r-nNfAE,4625
+tests/test_nc.py,sha256=Qhd8SppnWULcEiGphhhn4K_8PfhV7Wh17NAC63R_-N0,4630
 tests/test_parident.py,sha256=zwj-f-Q_s5dBr_fEvzd5iZqNVIcLwkoi_FF2_FNTiaw,1393
 tests/test_parstudy.py,sha256=wk7WfYQrx5dtv6MnmWCfNAEInvRKsbVXYEUIIR9zLbQ,3200
 tests/test_pocfile.py,sha256=eiMLBRQxDnHIGiqku6EXcQ3fb7wGIxhXmb20iyLlPRU,5816
@@ -220,9 +221,9 @@ tests/moo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/moo/test_algorithm.py,sha256=Em8sFm2vzPmuIzRrBBnUQLU_TYuJHSf-kEeozw0XeX4,2563
 tests/moo/test_population.py,sha256=FvX9LRCxQx0_E2GxHQ5vKwOYFBQiNbT6Lmv5GmNWjTQ,5471
 tests/moo/test_problem.py,sha256=ALeP4u7g-dFhfwWL8vxivdrrYzVKPjHMCAXzzgyNZbs,467
-femagtools-1.8.10.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
-femagtools-1.8.10.dist-info/METADATA,sha256=QfhuU-KoVeRf3mzg6SnYV0qb3IWyZH4Nb-vgj7fLd3o,6191
-femagtools-1.8.10.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-femagtools-1.8.10.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
-femagtools-1.8.10.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.8.10.dist-info/RECORD,,
+femagtools-1.8.12.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
+femagtools-1.8.12.dist-info/METADATA,sha256=Y7Cxd_Wdj5H25nX8oaFX9ZWBxCvupQPDWKZTnJc-nGM,6191
+femagtools-1.8.12.dist-info/WHEEL,sha256=beeZ86-EfXScwlR_HKu4SllMC9wUEj_8Z_4FJ3egI2w,91
+femagtools-1.8.12.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
+femagtools-1.8.12.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
+femagtools-1.8.12.dist-info/RECORD,,

{femagtools-1.8.10.dist-info → femagtools-1.8.12.dist-info}/WHEEL

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

tests/test_fsl.py

@@ -319,11 +319,11 @@ class FslBuilderTest(unittest.TestCase):
 
         feapars['calculationMode'] = "pm_sym_fast"
         fsl = self.builder.create_analysis(feapars)
-        self.assertEqual(len(fsl), 36)
+        self.assertEqual(len(fsl), 34)
 
         feapars['calculationMode'] = "mult_cal_fast"
         fsl = self.builder.create_analysis(feapars)
-        self.assertEqual(len(fsl), 34)
+        self.assertEqual(len(fsl), 32)
 
         feapars['calculationMode'] = "torq_calc"
         fsl = self.builder.create_analysis(feapars)

tests/test_nc.py

@@ -100,7 +100,7 @@ def test_geom(pm):
     assert g['h'] == pytest.approx(0.00308, abs=1e-5)
     assert g['cxy'] == pytest.approx((0.02317, 0.007528), abs=1e-5)
     assert g['area'] == pytest.approx(3.45e-05, abs=1e-6)
-    assert g['alpha'] == pytest.approx(1.885, abs=1e-3)
+    assert g['alpha'] == pytest.approx(-1.2566371, abs=1e-3)
 
 def test_calc_iron_loss(pm):
     import numpy as np