femagtools 1.8.1__py3-none-any.whl → 1.8.3__py3-none-any.whl

femagtools/machine/effloss.py

@@ -39,7 +39,7 @@ def iqd_tmech_umax(m, u1, with_mtpa, progress, speed_torque, iq, id, iex):
     finally:
         progress.close()
 
-def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa):
+def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa, publish=0):
     """calculate iqd for sm and pm using multiproc
     """
     progress_readers = []
@@ -79,6 +79,16 @@ def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa):
                 progress_readers.remove(r)
             else:
                 if i % len(progress_readers) == 0:
+                    if publish:
+                        numTot = len(collected_msg)
+                        numOf = f"{num_proc-numTot} of {num_proc}"
+                        workdone = sum([float(i[:-1])
+                                        for i in collected_msg]) / numTot
+                        logger.debug("numTot %d numOf %s workdone %s, %s",
+                                     numTot, numOf, workdone, collected_msg)
+                        publish(('progress_logger',
+                                 f"{numTot}:{numOf}:{workdone}:"))
+                        # {' '.join(collected_msg)}"))
                     logger.info("Losses/Eff Map: %s",
                                 ', '.join(collected_msg))
                     collected_msg = []
@@ -197,7 +207,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
       with_mtpa -- (optional) use mtpa if True (default), disables mtpv if False
       with_tmech -- (optional) use friction and windage losses (default)
       num_proc -- (optional) number of parallel processes (default 0)
-      progress  -- (optional) custom function for progress logging
+      progress  -- (optional) custom function for progress logging (publishing)
       with_torque_corr -- (optional) T is corrected if out of range (default False)
 
     Returns:
@@ -250,41 +260,42 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     logger.info("total speed,torque samples %d", ntmesh.shape[1])
     if isinstance(m, (PmRelMachine, SynchronousMachine)):
         if num_proc > 1:
-            iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa)
+            iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa,
+                                       publish=progress)
         else:
             class ProgressLogger:
-                def __init__(self, nsamples):
+                def __init__(self, nsamples, publish):
                     self.n = 0
+                    self.publish = publish
                     self.nsamples = nsamples
                     self.num_iv = round(nsamples/15)
                 def __call__(self, iqd):
                     self.n += 1
                     if self.n % self.num_iv == 0:
-                        logger.info("Losses/Eff Map: %d%%",
-                                    round(100*self.n/self.nsamples))
-            if progress is None:
-                progress = ProgressLogger(ntmesh.shape[1])
-            else:
-                try:
-                    progress.nsamples=ntmesh.shape[1]
-                    progress(0)  # To check conformity
-                    progress.n = 0
-                except:
-                    logger.warning("Invalid ProgressLogger given to efficiency_losses_map, using default one!")
-                    progress = ProgressLogger(ntmesh.shape[1])
+                        workdone=round(100*self.n/self.nsamples)
+                        if self.publish:
+                            self.publish(
+                                ('progress_logger',
+                                 f"{self.n}:{self.n} of {self.nsamples}:{workdone}"))
+                        logger.info("Losses/Eff Map: %d%%", workdone)
+
+            progress_logger = ProgressLogger(ntmesh.shape[1], progress)
+            progress_logger.nsamples = ntmesh.shape[1]
+            progress_logger(0)  # To check conformity
+            progress_logger.n = 0
             if with_tmech:
                 iqd = np.array([
                     m.iqd_tmech_umax(
                         nt[1],
                         2*np.pi*nt[0]*m.p,
-                        u1, log=progress, with_mtpa=with_mtpa)[:-1]
+                        u1, log=progress_logger, with_mtpa=with_mtpa)[:-1]
                     for nt in ntmesh.T]).T
             else:
                 iqd = np.array([
                     m.iqd_torque_umax(
                         nt[1],
                         2*np.pi*nt[0]*m.p,
-                        u1, log=progress, with_mtpa=with_mtpa)[:-1]
+                        u1, log=progress_logger, with_mtpa=with_mtpa)[:-1]
                     for nt in ntmesh.T]).T
 
         beta, i1 = betai1(iqd[0], iqd[1])

femagtools/machine/sizing.py

@@ -1,6 +1,6 @@
 """general design of an AC electrical machine
 
-   Types: spm, ipm, eesm, im
+   Types: spm, ipm, eesm, im, afpm
 
 """
 import numpy as np
@@ -10,6 +10,25 @@ from .utils import wdg_resistance
 
 logger = logging.getLogger("femagools.machine.sizing")
 
+AFPM_DEFAULTS = dict(
+    airgap=2e-3,
+    kd=0.7,  # ratio of inner vs outer diameter 0.6 .. 0.8
+    eta=0.92,  # efficiency
+    cos_phi=0.95,  # power factor
+    m=3,  # number of phases
+    ui_u=0.8,  # U ind / U
+    J=8.5e6,  # current density  A/mm²
+    sigmas=40e3,  # shear force 30 .. 65 kN/m2
+    Ba=0.7,  # flux density in airgap
+    Bth=1.5,  # flux density in teeth 1.5 .. 2 T
+    By=1.2,  # flux density in yoke 1.2 .. 1.5 T
+    kq=0.6,  # stator winding fill factor 0.35 .. 0.75
+    mag_width=0.95,  # rel magnet width 0.6 .. 1
+    Hc=700,  # max. coercitive field strength, 500 .. 900 kA/m
+    brem=1.2,  # remanence 0.3 .. 1.3 T
+    demag=6  # safety factor for demagnetisation (nom current)
+)
+"""default sizing parameters for AFPM"""
 
 PM_DEFAULTS = dict(
     airgap=1.5e-3,  # airgap width m
@@ -217,7 +236,7 @@ def _stator_slots(par, slots):
          # check sim factor, height/width ratio
         if qhbmin[1] == len(q)-1:
             # last has smallest sim factor
-             return q[qhbmin[1]][0]
+            return q[qhbmin[1]][0]
         elif q[qhbmin[1]][2] < q[qhbmin[1]+1][2]:
             # select ideal height/width ratio (3.2)
             return q[qhbmin[1]][0]
@@ -270,7 +289,7 @@ def get_stator_dimensions(par, slots=[]):
     Ui_U = par['ui_u']
 
     # design parameters
-    # AJ = papyr['AJ'] # 100*1e9 # thermal load, typically 100 .. 300 A²/mm³
+    # AJ = par['AJ'] # 100*1e9 # thermal load, typically 100 .. 300 A²/mm³
     J = par['J']   # current density 3 .. 6 A/mm²
     Ba = par['Ba']     # airgap flux density, typically 0.6 .. 1.5 T
     kq = par['kq']      # winding fill factor, typically 0.35 .. 0.75
@@ -431,15 +450,13 @@ def get_stator_dimensions(par, slots=[]):
 
     return r
 
-
 def _get_magnet_height(I1, N, kw, par):
     airgap = par['airgap']
     Ba = par['Ba']
     p = par['p']
     m = par['m']
 
-    Hc = par['Hc']
-    Hc = Hc*1e3  # unit kA/m
+    Hc = par['Hc']*1e3  # unit kA/m -> A/m
     # Safety Factor for demagnetization
     demag = par['demag']
     THETA1 = m/np.pi*np.sqrt(2)*I1*N*kw/p
@@ -611,8 +628,9 @@ def get_sm_rotor_dimensions(A, psi1, lfe, Da2, par):
     mue0 = 4*np.pi*1e-7
 
     wf = wp - wc
-    anr = par['airgap']*par['Ba']/mue0/par['J']/par['kqr']
-
+    NI = par['airgap']*par['Ba']/mue0
+    anr = NI/par['J']/par['kqr']
+    r['NI'] = NI
     a = np.tan(alphap/2)/2
     b = (wp/2 - wc + np.tan(alphap/2)*(Da2/2 - hp))/2
     hc = min(max(4*anr/(wc+wp), 0.75*hfmax), hfmax)
@@ -648,6 +666,10 @@ def _set_defaults(par, defaults):
             par[k] = defaults[k]
 
 
+def _set_afpm_defaults(par):
+    _set_defaults(par, AFPM_DEFAULTS)
+
+
 def _set_pm_defaults(par):
     _set_defaults(par, PM_DEFAULTS)
 
@@ -708,6 +730,163 @@ def spm(pnom: float, speed: float, p: int, **kwargs) -> dict:
     return r
 
 
+def afpm(pnom: float, speed: float, p: int, afmtype: str, **kwargs) -> dict:
+    """returns dimension of a AFPM machine
+
+    Args:
+    pnom: power at rated speed (W)
+    speed: rotation speed (1/s)
+    p: number of pole pairs
+    afmtype: one of 'S1R1', 'S2R1', 'S1R2'
+
+    udc: (optional) DC link voltage (V)
+    u1: (optional)  phase voltage (Vrms)
+    Q1: (optional) total number of stator slots
+    brem: (optional) remanence of magnet (T)
+    """
+    par = dict(
+        pnom=pnom, speed=speed, p=p)
+    par.update(kwargs)
+    _set_afpm_defaults(par)
+
+    kp = 1 if afmtype == 'S1R1' else 2
+    kps = 1 if afmtype in ('S1R1', 'S1R2') else 2
+    kpr = 2 if afmtype == 'S1R2' else 1
+    kd = par['kd']  # ratio of inner_diam/outer_diam
+    tnom = pnom/(2*np.pi*speed)
+    sigmas = par['sigmas']  # shear force
+    # outer diameter:
+    # https://web.mit.edu/kirtley/binlustuff/literature/electric%20machine/designOfAxialFluxPMM.pdf
+    Do = 2*np.power(tnom/(kp*sigmas*np.pi*kd*(1-kd**2)), 1/3)
+    Di = Do*kd
+    # pole width and iron length
+    Davg = (Do+Di)/2
+    taup = np.pi * Davg/(2*p)
+    lfe = (Do-Di)/2
+    # flux density in airgap
+    Bd1 = 4.0/np.pi*par['Ba']*np.sin(np.pi/2.0*par['mag_width'])
+
+    # rated phase voltage
+    if 'udc' in par:
+        u1nom = 0.9*par['udc']/np.sqrt(2)/np.sqrt(3)
+    else:
+        u1nom = par['u1']
+    f1 = speed*p
+    # flux linkage
+    psi1 = kpr*2.0/np.pi*taup*lfe*Bd1
+
+    # winding factor
+    Q1 = par['Q1']
+    m = par['m']
+    yd = par.get('coil_span', 0)
+    if yd:
+        wdg = Winding({'Q': par['Q1'], 'p': par['p'], 'm': 3,
+                       'yd': yd, 'l': 2})
+    else:
+        wdg = Winding({'Q': par['Q1'], 'p': par['p'], 'm': 3, 'l': 2})
+
+    kw = wdg.kw()
+
+    Ui = par['ui_u'] * u1nom
+    N = np.sqrt(2)*Ui/(2*np.pi*f1*kw*psi1)
+
+    # feasible number of turns per coil...
+    layers = wdg.l
+    # coils per phase (kps: number of stators)
+    ncoils = kps*Q1 // 2 // m * layers
+    ngroups = [1] + [g for g in range(2, layers*p + 1) if layers * p % g == 0]
+    ndiff = [abs(N - ncoils // a * a * round(N / ncoils))
+             for a in ngroups]
+    logger.debug("N %f ngroups %s ndiffs %s", N, ngroups, ndiff)
+    # parallel groups
+    a_calc = ngroups[np.argmin(ndiff)]
+    a = par.get("a", a_calc)
+    if a not in ngroups:
+        logger.warning("Check given number %s of parallel wdg groups. Valid ngroups are: %s",
+                       a, ngroups)
+    # num wires per coil side (number of coil groups a)
+    num_wires = round(a * N / ncoils)
+
+    # correction of number of turns per phase
+    N_old = N
+    N = num_wires * ncoils / a
+
+    # correction of voltage
+    Ui = Ui/N_old*N
+    u1nom = Ui/par['ui_u']
+
+    # current loading
+    # A = np.sqrt(2)*sigmas/kw/Ba
+    I1 = pnom/(m*par['eta']*par['cos_phi']*u1nom)
+    A = 2*m*N*I1/np.pi/Di
+    # slot area
+    # J = AJ/A
+    hs1 = 1e-3  # slot opening height
+    taus = np.pi/Q1
+    ans = taus*Di*A/(par['kq']*par['J'])
+    bds = taus*(Di+2*hs1)*Bd1/par['Bth']
+    bns = taus*(Di+2*hs1) - bds
+
+    hns = (-bns + np.sqrt(bns**2 + 4*ans*np.tan(taus)))/2/np.tan(taus)/kps
+    hys = psi1/2/lfe/par['By']/kps
+
+    aw = ans * par['kq'] / layers / num_wires * kps
+
+    r = {'outer_diam': Do, 'inner_diam': Di, 'airgap': par['airgap']/kp,
+         'afmtype': afmtype, 'lfe': lfe,
+         'poles': 2*p,
+         'ans': round(ans, 6),
+         'hns': round(hns, 4),
+         'bns': round(bns, 4),
+         'A': round(A, 3),
+         'AJ': round(par['J']*A, 0),
+         'w1': int(N),
+         'kw': round(kw, 4),
+         'ess': round(1e-3*pnom/(60*speed)/(Do**2*lfe), 4),
+         'q': wdg.q,
+         'i1': round(I1, 3),  # np.pi*Da1*A/2/m/N
+         'psi1': round(psi1, 5),
+         'u1': u1nom,
+         'ui': Ui}
+    hs1 = 0
+    hs2 = 0
+    r['stator'] = dict(
+        u1nom=round(u1nom, 1), f1nom=round(f1, 1),
+        num_slots=Q1,
+        nodedist=1,
+        # num_slots_gen = req_poles*Q1/2/p,
+        afm_stator=dict(
+            slot_width=r['bns'],
+            slot_height=hs1+r['hns'],
+            slot_h1=hs1,
+            slot_h2=hs1,
+            slot_open_width=r['bns'],
+            slot_r1=0,
+            slot_r2=0,  # bns2/2,
+            yoke_height=round(hys, 4) if kpr == 1 else 0))
+
+    relculen = 1.4
+    r['winding'] = dict(
+        #wire_diam=round(dwire, 5),
+        num_phases=m,
+        cufilfact=par['kq'],
+        culength=relculen,
+        num_par_wdgs=a,
+        num_layers=layers,
+        #resistance=round(r1, 4),
+        coil_span=wdg.yd,
+        num_wires=int(num_wires))
+
+    hm = _get_magnet_height(r['i1'], r['w1'], r['kw'], par)/kpr
+    r['magnet'] = dict(
+        afm_rotor=dict(
+            yoke_height=round(hys/kpr, 4) if kps == 1 else 0,
+            rel_magn_width=par['mag_width'],
+            magn_height=round(hm, 4))
+    )
+    return r
+
+
 def ipm(pnom: float, speed: float, p: int, **kwargs) -> dict:
     """returns dimension of a IPM machine
 
@@ -808,11 +987,11 @@ def eesm(pnom: float, speed: float, p: int, **kwargs) -> dict:
 
 
 if __name__ == "__main__":
-
-    pnom = 10e3
-    speed = 4400/60
-    p = 4
-    udc = 600
+    # sizing example with SPM
+    pnom = 10e3  # shaft power in W
+    speed = 4400/60  # speed in 1/s
+    p = 4  # number of pole pairs
+    udc = 600  # DC voltage in V
 
     r = spm(pnom, speed, p, udc=udc)
 

femagtools/machine/sm.py

@@ -434,9 +434,9 @@ class SynchronousMachine(object):
     def iqd_tmech(self, torque, n, disp=False, maxiter=500):
         """return currents for shaft torque with minimal losses"""
         if torque > 0:
-            startvals = self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = self.bounds[0][1], 0, self.bounds[-1][1]
         else:
-            startvals = -self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = -self.bounds[0][1]/2, 0, self.bounds[-1][1]
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -463,9 +463,9 @@ class SynchronousMachine(object):
     def iqd_torque(self, torque, disp=False, maxiter=500):
         """return currents for torque with minimal losses"""
         if torque > 0:
-            startvals = self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = self.bounds[0][1]/2, 0, self.bounds[-1][1]
         else:
-            startvals = -self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = -self.bounds[0][1]/2, 0, self.bounds[-1][1]
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -483,14 +483,14 @@ class SynchronousMachine(object):
             #options={'disp': disp, 'maxiter': maxiter})
             if res['success']:
                 return res.x
-            logger.warning("%s: torque=%f %f, io=%s",
-                           res['message'], torque, self.torque_iqd(*startvals),
-                           startvals)
+        logger.warning("%s: torque=%f %f, io=%s",
+                       res['message'], torque, self.torque_iqd(*startvals),
+                       startvals)
         raise ValueError(res['message'])
 
     def mtpa(self, i1max):
         """return iq, id, iex currents and maximum torque per current """
-        T0 = self.torque_iqd(np.sqrt(2)*i1max/2, 0, self.bounds[-1][1]/2)
+        T0 = self.torque_iqd(np.sqrt(2)*i1max, 0, self.bounds[-1][1])
         def i1tq(tq):
             return abs(i1max) - np.linalg.norm(self.iqd_torque(tq)[:2])/np.sqrt(2)
         with warnings.catch_warnings():
@@ -501,7 +501,7 @@ class SynchronousMachine(object):
 
     def mtpa_tmech(self, i1max, n):
         """return iq, id, iex currents and maximum torque per current """
-        T0 = self.torque_iqd(np.sqrt(2)*i1max/2, 0, self.bounds[-1][0])/2
+        T0 = self.torque_iqd(np.sqrt(2)*i1max, 0, self.bounds[-1][1])
         def i1tq(tq):
             return i1max - np.linalg.norm(self.iqd_tmech(tq, n)[:2])/np.sqrt(2)
         tq = so.fsolve(i1tq, T0)[0]
@@ -517,14 +517,11 @@ class SynchronousMachine(object):
             if log:
                 log(iqde)
             return (*iqde, torque)
-        beta, i1 = betai1(iqde[0], iqde[1])
-        iex = iqde[2]
+        #beta, i1 = betai1(iqde[0], iqde[1])
+        #iex = iqde[2]
 
-        def ubeta(b):
-            return np.sqrt(2)*u1max - np.linalg.norm(
-                self.uqd(w1, *iqd(b, i1), iex))
-        beta = -np.pi/4 if torque>0 else -3*np.pi/4
-        io = *iqd(beta, i1), iex
+        #beta = 0 if torque>0 else np.pi
+        io = iqde[0], 0, iqde[2] #*iqd(beta, i1), iex
 
         #    logger.debug("--- torque %g io %s", torque, io)
         with warnings.catch_warnings():
@@ -540,17 +537,18 @@ class SynchronousMachine(object):
                 bounds=self.bounds,
                 constraints=[
                     {'type': 'eq',
-                     'fun': lambda iqd: self.tmech_iqd(*iqd, n) - torque},
+                     'fun': lambda iqd: torque - self.tmech_iqd(*iqd, n)},
                     {'type': 'eq',
-                     'fun': lambda iqd: np.linalg.norm(
-                         self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}])
+                     'fun': lambda iqd: u1max*np.sqrt(2)
+                       - np.linalg.norm(self.uqd(w1, *iqd))}])
             #if res['success']:
-        if log:
-            log(res.x)
-        return *res.x, self.tmech_iqd(*res.x, n)
-    #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-    #               res['message'], w1, torque, u1max, io)
-    #raise ValueError(res['message'])
+            if log:
+                log(res.x)
+            return *res.x, self.tmech_iqd(*res.x, n)
+        #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+        #               res['message'], w1, torque, u1max, io)
+        #raise ValueError(res['message'])
+        #return [float('nan')]*4
 
     def iqd_torque_umax(self, torque, w1, u1max,
                         disp=False, maxiter=500, log=0, **kwargs):
@@ -579,16 +577,15 @@ class SynchronousMachine(object):
                     {'type': 'eq',
                      'fun': lambda iqd: self.torque_iqd(*iqd) - torque},
                     {'type': 'eq',
-                     'fun': lambda iqd: np.linalg.norm(
-                         self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}])
-            if res['success']:
-
-                if log:
-                    log(res.x)
-                return *res.x, self.torque_iqd(*res.x)
-            logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-                           res['message'], w1, torque, u1max, io)
-        raise ValueError(res['message'])
+                     'fun': lambda iqd: u1max*np.sqrt(2) - np.linalg.norm(
+                         self.uqd(w1, *iqd))}])
+            #if res['success']:
+            if log:
+                log(res.x)
+            return *res.x, self.torque_iqd(*res.x)
+            #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+            #               res['message'], w1, torque, u1max, io)
+            #raise ValueError(res['message'])
 
     def w1_imax_umax(self, i1max, u1max):
         """return frequency w1 and shaft torque at voltage u1max and current i1max
@@ -672,9 +669,10 @@ class SynchronousMachine(object):
 
         wmtab = []
         dw = 0
-        wmMax = 3.5*wmType
+        wmMax = 5*wmType
         if n > 0:
             wmMax = min(wmMax, 2*np.pi*n)
+
         if wmType > wmMax:
             wmrange = sorted([0, wmMax])
             wmtab = np.linspace(0, wmMax, nsamples).tolist()

femagtools/machine/utils.py

@@ -449,8 +449,8 @@ def dqparident(workdir, engine, temp, machine,
     leakfile.unlink(missing_ok=True)
 
     period_frac = kwargs.get('period_frac', 6)
-    if machine.get('external_rotor', False):
-        period_frac = 1  # TODO: missing femag support
+    if machine.get('external_rotor', False) and period_frac > 1:
+        logger.warning("period frac for external rotor requires GT femag version >= 2024")
 
     if dqtype == 'ldq':
         simulation = dict(