femagtools 1.8.0__py3-none-any.whl → 1.8.2__py3-none-any.whl

femagtools/femag.py

@@ -359,42 +359,71 @@ class BaseFemag(object):
 
         return dict()
 
-    def read_hsn(self, modelname=None): 
+    def read_hsn(self, modelname=None):
+        import numpy as np
         "read heat network result"
         _map = {
-            "StZa": "plfe1", 
+            "StZa": "plfe1",
             "outs": "-",
-            "StJo": "plfe1", 
+            "StJo": "plfe1",
             "Slot": "-",
-            "Shaf": "-", 
-            "Iron": "plfe2", 
+            "Shaf": "-",
+            "Iron": "plfe2",
             "PMag": "plmag",
             "PMag_1": "plmag",
             "PMag_2": "plmag",
             "PMag_3": "plmag",
             "PMag_4": "plmag",
-            "W1  ":   "plcu1", 
-            "W2  ":   "plcu1", 
+            "W1  ":   "plcu1",
+            "W2  ":   "plcu1",
             "W3  ":   "plcu1"
         }
         if not modelname:
             modelname = self._get_modelname_from_log()
         hsn_list = sorted(glob.glob(os.path.join(
             self.workdir, modelname+'.hsn')))
-        with open(hsn_list[-1], 'r') as f: 
+        with open(hsn_list[-1], 'r') as f:
             hsn_data = json.load(f)
+
+        # area calculation
+        nc_file = self.read_nc(modelname)
+        slot_area = 0.0
+        wdg_area = []
+        for i in nc_file.windings:
+            for j in i.subregions:
+                wdg_area.append(j.area())
+
+        slot_area = np.sum(wdg_area).item()/3
+        magnet_area = 0.0
+        num_sreg_mag = 0
+        area = dict()
+        for i in nc_file.subregions:
+            if i.name in ("StZa", "StJo", "Iron"):
+                area[i.name] = i.area().item()
+            elif i.name == "PMag":
+                magnet_area += i.area().item()
+                num_sreg_mag += 1
+            else:
+                pass
+
+        area['PMag'] = magnet_area/num_sreg_mag
+        for i in ('W1', 'W2', 'W3'):
+            area[i] = slot_area
+
         pmag_index = []
-        if "Nodes" in hsn_data: 
-            for k ,i in enumerate(hsn_data['Nodes']): 
+        if "Nodes" in hsn_data:
+            for k ,i in enumerate(hsn_data['Nodes']):
                 i.update({"mass": i['weight'], "losses": _map[i['Name']]})
-                if "PMag" in i['Name']: 
+                if "PMag" in i['Name']:
                     pmag_index.append(k)
-            if pmag_index: 
-                for i in range(len(pmag_index)): 
-                    hsn_data["Nodes"][pmag_index[i]]['Name'] = f"PMag_{i+1}" 
-        with open(hsn_list[-1], 'w') as f: 
+                if i['Name'].strip() in area.keys():
+                    i.update({"area": area[i['Name'].strip()]})
+            if pmag_index:
+                for i in range(len(pmag_index)):
+                    hsn_data["Nodes"][pmag_index[i]]['Name'] = f"PMag_{i+1}"
+        with open(hsn_list[-1], 'w') as f:
             json.dump(hsn_data, f)
-        return hsn_data
+        return nc_file
 
     def _get_modelname_from_log(self):
         """
@@ -439,11 +468,13 @@ class BaseFemag(object):
                 return {'t': ttemp[0], 'temperature': ttemp[1]}
 
             if simulation['calculationMode'] == 'hsn':
-                try: 
-                    hsn_result = self.read_hsn()
-                except: 
-                    pass 
-                model = self.read_nc()
+                model = None
+                try:
+                    model = self.read_hsn()
+                except:
+                    pass
+                if model is None:
+                    model = self.read_nc()
                 return model.get_minmax_temp()
 
             if not bch:
@@ -497,7 +528,8 @@ class BaseFemag(object):
                 ops = [k for k in range(len(bch.torque))]
                 m = femagtools.ecloss.MagnLoss(self.workdir, self.modelname, ibeta=ops)
                 try:
-                    magn_losses = m.calc_losses()
+                    # change from ialh to ialh2: since v1.8.1
+                    magn_losses = m.calc_losses_ialh2()
                 except:
                     magn_losses = [0 for i in range(len(ops))]
 
@@ -513,11 +545,11 @@ class BaseFemag(object):
                     bch.magnet_loss_th = m.th_loss
                 except:
                     pass
-            try: 
-                if hasattr(self, 'dy2'): 
+            try:
+                if hasattr(self, 'dy2'):
                     setattr(bch, 'dy2', self.dy2)
-            except: 
-                pass 
+            except:
+                pass
             return bch
 
 
@@ -649,10 +681,10 @@ class Femag(BaseFemag):
             stateofproblem = 'mag_static'
 
         self.run(fslfile, options, fsl_args, stateofproblem=stateofproblem)
-        
-        try: 
+
+        try:
             setattr(self, "dy2", machine['stator']['dy2'])
-        except: 
+        except:
             pass
         if simulation:
             return self.readResult(simulation)

femagtools/fsl.py

@@ -157,10 +157,18 @@ class Builder:
                     + model.stator['dxf']['fsl'])
         if templ == 'statorFsl':
             #  obsolete
+            th_props = [' ']
+            try:
+                th_props = [f'stator_density = {model.stator["density"]}',
+                            f'stator_thcond = {model.stator["thcond"]}',
+                            f'stator_thcap = {model.stator["thcap"]}',
+                            ]
+            except:
+                pass
             if 'parameter' in model.stator['statorFsl']:
                 return self.render_template(
                     model.stator['statorFsl']['content_template'],
-                    model.stator['statorFsl']['parameter'])
+                    model.stator['statorFsl']['parameter']) + th_props
             elif model.stator['statorFsl'].get('content'):
                 return (['agndst = {}'.format(model.get('agndst', 1e-3)*1e3),
                         'ndt(agndst)'] +
@@ -214,14 +222,22 @@ class Builder:
                .format(model.magnet.get('mcvkey_yoke', 'dummy')),
                "mcvkey_shaft = '{}'"
                .format(model.magnet.get('mcvkey_shaft', 'dummy'))]
-
         if 'magnetFsl' in model.magnet:
             self.fsl_rotor = True
             #  obsolete
+            th_props = [' ']
+            try:
+                logger.info(model.magnet)
+                th_props = [f'rotor_density = {model["magnet"]["density"]}',
+                            f'rotor_thcond = {model["magnet"]["thcond"]}',
+                            f'rotor_thcap = {model["magnet"]["thcap"]}'
+                            ]
+            except:
+                pass
             if 'parameter' in model.magnet['magnetFsl']:
                 return mcv + self.render_template(
                     model.magnet['magnetFsl']['content_template'],
-                    model.magnet['magnetFsl']['parameter'])
+                    model.magnet['magnetFsl']['parameter']) + th_props
             elif model.magnet['magnetFsl'].get('content'):
                 return mcv + model.magnet['magnetFsl']['content'].split('\n')
             if isinstance(model.magnet['magnetFsl']
@@ -231,7 +247,6 @@ class Builder:
                     templ = [l.strip() for l in f.readlines()]
             else:
                 templ = model.magnet['magnetFsl']['content_template']
-
             return mcv + self.render_template(
                 '\n'.join(templ),
                 model.magnet['magnetFsl'])
@@ -349,8 +364,8 @@ class Builder:
         """return connect_model if rotating machine and incomplete model
         (Note: femag bug with connect model)"
         """
-        if (model.get('move_action') == 0 and (
-                model.connect_full or
+        if (model.connect_full or (
+                model.get('move_action', 0) == 0 and
                 model.stator['num_slots'] > model.stator['num_slots_gen'])):
             fslcmds = ['pre_models("connect_models")\n']
             if 'thcond' in model.stator:

femagtools/machine/__init__.py

@@ -68,8 +68,9 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
         psid = rwdg*rlfe*dqp['psid']
         psiq = rwdg*rlfe*dqp['psiq']
         losses = __scale_losses(dqp['losses'], rlfe)
-        losses['ef'] = dqpars[-1]['losses']['ef']
-        losses['eh'] = dqpars[-1]['losses']['ef']
+        losses['ef'] = dqpars[-1]['losses'].get('ef', [2.0, 2.0])
+        losses['hf'] = dqpars[-1]['losses'].get('hf', [1.0, 1.0])
+        # TODO handle bertotti excess loss factor
 
         if 'psidq' in eecpars:
             machine = PmRelMachinePsidq(
@@ -140,7 +141,7 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             try:
                 losses = __scale_losses(bch.psidq['losses'], rlfe)
                 losses['ef'] = bch.lossPar.get('ef', [2.0, 2.0])
-                losses['eh'] = bch.lossPar.get('eh', [1.0, 1.0])
+                losses['hf'] = bch.lossPar.get('hf', [1.0, 1.0])
             except KeyError:
                 losses = {}
             if 'ex_current' in bch.machine:
@@ -162,7 +163,7 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             try:
                 losses = __scale_losses(bch.ldq['losses'], rlfe)
                 losses['ef'] = bch.lossPar.get('ef', [2.0, 2.0])
-                losses['eh'] = bch.lossPar.get('eh', [1.0, 1.0])
+                losses['hf'] = bch.lossPar.get('hf', [1.0, 1.0])
             except KeyError:
                 losses = {}
             if 'ex_current' in bch.machine:

femagtools/machine/afpm.py

@@ -25,6 +25,25 @@ AFM_TYPES = (
     "S2R1_all"   # 2 stator, 1 rotor, all simulated
 )
 
+def num_agnodes(Q, p, pw, ag):
+    """return total number of nodes in airgap per pole
+     Args:
+      Q: (int) number of slots
+      p: (int) number of pole pairs
+      pw: (float) pole width
+      ag: (float) airgap height
+    """
+    num_nodes = np.arange(12, 120, 6)
+    i = np.argmin(np.abs(pw/num_nodes - ag/2))
+    if p*num_nodes[i-1] % Q:
+        lcm = np.lcm(Q, 2*p)//p
+        nmin, nmax = num_nodes[0]//lcm, num_nodes[-1]//lcm
+        num_nodes = np.array(
+            [i*lcm for i in range(nmin, nmax) if i*lcm % 6 == 0])
+        i = np.argmin(np.abs(pw/num_nodes - ag/2))
+        # nodedist 0.5, 2, 4, 6
+    return num_nodes[i-1]
+
 def _integrate(radius, pos, val):
     interp = RegularGridInterpolator((radius, pos), val)
     def func(x, y):
@@ -141,10 +160,8 @@ def parident(workdir, engine, temp, machine,
 
     if "num_agnodes" not in machine:
         for pw in pole_width:
-            machine['num_agnodes'] = 6*round(pw/machine['airgap']/4)
-
-            #if machine['num_agnodes'] < nper:
-            #    machine['num_agnodes'] = 8*round(pw/machine['airgap']/4)
+            machine['num_agnodes'] = num_agnodes(Q1, p//2, pw,
+                                                 machine['airgap'])
 
     nlparvardef = {
         "decision_vars": [
@@ -189,7 +206,8 @@ def parident(workdir, engine, temp, machine,
 
             nlresults = pstudy(nlparvardef, machine, nlcalc, engine)
             if nlresults['status'].count('C') != len(nlresults['status']):
-                raise ValueError('Noload simulation failed %s', nlresults['status'])
+                raise ValueError(
+                    f"Noload simulation failed {nlresults['status']}")
         else:
             nlresults = {"x": [], "f": []}
             i = 0
@@ -210,7 +228,7 @@ def parident(workdir, engine, temp, machine,
                 nlresults['f'].append({k: v for k, v in r.items()})
                 i = i + 1
         nlresults.update(process(lfe, pole_width, machine, nlresults['f']))
-
+        weights = nlresults['weights']
         current_angles = nlresults['f'][0]['current_angles']
         results = []
         i = 0
@@ -325,7 +343,7 @@ def parident(workdir, engine, temp, machine,
                                       (-1, num_beta_steps)),
                            axis=1).T.tolist()})
         ldq.append({'temperature': magtemp,
-                    'i1':i1, 'beta':beta,
+                    'i1': i1, 'beta': beta,
                     'psid': psid.tolist(), 'psiq': psiq.tolist(),
                     'ld': ld, 'lq': lq,
                     'torque': torque.tolist(),
@@ -334,7 +352,8 @@ def parident(workdir, engine, temp, machine,
         #iq, id = femagtools.machine.utils.iqd(*np.meshgrid(beta, i1))
 
     return {'m': machine[wdgk]['num_phases'],
-            'p': machine['poles']//2,
+            'p': machine['poles']//2, 'weights': weights,
+            'rotor_mass': sum(weights[1]), "kfric_b": 1,
             'ls1': 0, 'r1': r1, 'ldq': ldq}
 
 
@@ -442,8 +461,17 @@ def process(lfe, pole_width, machine, bch):
                         mmod.outer_diam, mmod.inner_diam)
     i1 = np.mean([np.max(c) for c in currents])/np.sqrt(2)
     plcu = mmod.winding['num_phases']*i1**2*r1
+    weights = np.array([[0, 0, 0], [0, 0, 0]])
+    try:
+        for b in bch:
+            weights = weights + b['weights']
+        weights *= scale_factor
+    except KeyError as exc:
+        #logger.warning("missing key %s", exc)
+        pass
 
     return {
+        'weights': weights.tolist(),
         'pos': pos.tolist(), 'r1': r1,
         'torque': torque,
         'emf': emf,
@@ -603,14 +631,12 @@ class AFPM:
                     for pw in pole_width]
 
         if "num_agnodes" not in machine:
+            Q1 = machine['stator']['num_slots']
+            p = machine['poles']
             for pw in pole_width:
-                machine['num_agnodes'] = 6*round(pw/machine['airgap']/4)
-                #Q = machine['stator']['num_slots']
-                #p = machine['poles']
-                #nper = np.lcm(Q, p)
-                #if machine['num_agnodes'] < nper:
-                #    machine['num_agnodes'] = 8*round(pw/machine['airgap']/4)
-
+                machine['num_agnodes'] = num_agnodes(Q1, p//2, pw,
+                                                     machine['airgap'])
+            logger.info("Num agnodes/pole %d", machine['num_agnodes'])
         parvardef = {
             "decision_vars": [
                 {"values": pole_width,

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
@@ -648,6 +665,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 +729,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/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 +986,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

@@ -344,13 +344,13 @@ class SynchronousMachine(object):
             freq = w/2/np.pi
             kr = self.zeta1[0]*freq**3 + self.zeta1[1]*freq**2 + \
                 self.zeta1[2]*freq + self.zeta1[3]
-            if isinstance(kr, list): 
+            if isinstance(kr, list):
                 kr = np.array(kr)
                 kr[kr<1.0] = 1.0
             elif isinstance(kr, np.ndarray):
                 kr[kr<1.0] = 1.0
-            else: 
-                if kr < 1.0: 
+            else:
+                if kr < 1.0:
                     kr = 1.0
             return self.r1*(1 + self.kth1*(self.tcu1 - 20))*kr  # ref 20°C
         sr = self.skin_resistance[0]
@@ -806,10 +806,7 @@ class SynchronousMachinePsidq(SynchronousMachine):
             if 'styoke_excess' in eecpars[idname][0]['losses'] and \
                np.any(np.array(eecpars[idname][0]['losses']['styoke_excess'])):
                 self.bertotti = True
-                keys.update({{
-                    'styoke_excess': 1.5,
-                    'stteeth_excess':1.5,
-                    'rotor_excess': 1.5}})
+                keys += ['styoke_excess', 'stteeth_excess','rotor_excess']
             if islinear:
                 pfe = {k: np.array([l['losses'][k]
                                     for l in eecpars[idname]])
@@ -926,10 +923,7 @@ class SynchronousMachineLdq(SynchronousMachine):
             if 'styoke_excess' in eecpars[idname][0]['losses'] and \
                np.any(np.array(eecpars[idname][0]['losses']['styoke_excess'])):
                 self.bertotti = True
-                keys.update({{
-                    'styoke_excess': 1.5,
-                    'stteeth_excess':1.5,
-                    'rotor_excess': 1.5}})
+                keys += ['styoke_excess', 'stteeth_excess','rotor_excess']
 
             if islinear:
                 pfe = {k: np.array([l['losses'][k]

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(

femagtools/mcv.py

@@ -335,9 +335,8 @@ class Mcv(object):
             self.setData(data)
 
             self.mc1_curves = len(self.curve)
-            if self.mc1_type == MAGCRV and self.mc1_curves > 1:
-                self.mc1_type = ORIENT_CRV
-            if self.mc1_type in (ORIENT_CRV, ORIENT_PM_CRV):
+            if (self.mc1_type in (ORIENT_CRV, ORIENT_PM_CRV)
+                or self.mc1_curves > 1):
                 self.version_mc_curve = self.ORIENTED_VERSION_MC_CURVE
             elif self.mc1_type == DEMCRV_BR:
                 self.version_mc_curve = self.PARAMETER_PM_CURVE