femagtools 1.8.9__py3-none-any.whl → 1.8.11__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.9'
+__version__ = '1.8.11'
 __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'):
+            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'))
@@ -211,11 +215,7 @@ def parident(workdir, engine, temp, machine,
         rmagw = num_slices*[machine['magnet'][slotmodel]['rel_magn_width']]
     else:
         rmagw = machine['magnet'][slotmodel]['rel_magn_width']
-        if len(rmagw) == 1:
-            num_slices = kwargs.get('num_slices', 3)
-            rmagw = num_slices*list(rmagw)
-        else:
-            num_slices = len(rmagw)
+        num_slices = len(rmagw)
 
     logger.info("num_slices %d rmagw %s", num_slices, rmagw)
     lfe = get_arm_lengths(machine['outer_diam'],

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,8 +179,11 @@ 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:
@@ -206,11 +209,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]

femagtools/shortcircuit.py

@@ -135,7 +135,7 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
         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:

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/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.9.dist-info → femagtools-1.8.11.dist-info}/METADATA

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

@@ -1,4 +1,4 @@
-femagtools/__init__.py,sha256=PWCIZG-FFAcwgx3DdNrvXuU1HpMNmFzbAzIZJ-2Biv4,1600
+femagtools/__init__.py,sha256=OjqGiMTH-XiYM7D-s7y7ZBDVyqoZzGDKh78C5m5kB78,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=hP2TBxjHXsWhrc6Uhd8s2ODVRqmMfsW8dFS2h-d6OwE,36990
 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=vsXR2aamfVpdP9wEz-_ZT_KpFE256lg_sP_6dAQ3rOs,19866
 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=_A_7csabj5gfRR7bfqNuC05-2HqP2-UMiYX4BSvfpQs,13936
 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=lNfJ8vvq70e3G5pLwW7t_ynRBOPgbgvd1Jgi9sIbBMI,40239
-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
@@ -144,7 +144,7 @@ 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
@@ -184,7 +184,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 +199,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 +220,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.9.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
-femagtools-1.8.9.dist-info/METADATA,sha256=hMiKfPVFbKiP4TvfbVxXIVzk5VSOv7-hYJuz9uejQr0,6190
-femagtools-1.8.9.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-femagtools-1.8.9.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
-femagtools-1.8.9.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.8.9.dist-info/RECORD,,
+femagtools-1.8.11.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
+femagtools-1.8.11.dist-info/METADATA,sha256=S4Peo7fKYPOUPvhtG7ZkLhuluCeYh4ZlhdoQH7AIor4,6191
+femagtools-1.8.11.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+femagtools-1.8.11.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
+femagtools-1.8.11.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
+femagtools-1.8.11.dist-info/RECORD,,

{femagtools-1.8.9.dist-info → femagtools-1.8.11.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (76.0.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