femagtools 1.6.8__py3-none-any.whl → 1.7.0__py3-none-any.whl

femagtools/machine/sizing.py

@@ -6,7 +6,7 @@
 import numpy as np
 import logging
 
-logger = logging.getLogger("femagools.machineo.sizing")
+logger = logging.getLogger("femagools.machine.sizing")
 
 
 PM_DEFAULTS = dict(
@@ -94,13 +94,6 @@ def wdg_resistance(w1, l, d):
     return 2*w1*l/S/a
 
 
-def current_losses(w1, l, d, i1):
-    # w1: num turns/phase
-    # l: wire length/slot
-    # d: wire diameter
-    return wdg_resistance(w1, l, d) * i1**2
-
-
 def check_symmetry_conditions(Q1, p, layers, m):
     # if Q1 % 2*p == 0:
     #    raise ValidationError("Number of slots Q and poles 2*p are not prime to each other")
@@ -227,6 +220,10 @@ def _stator_slots(par, slots):
 
 
 def get_stator_dimensions(par, slots=[]):
+    # Check symmetry
+    if 'Q1' in par:
+        from ..windings import Winding
+        wdg = Winding({'Q': par['Q1'], 'p': par['p'], 'm': 3})
     # nominal (rated) operating parameters
     pnom = par['pnom']
     speednom = par['speed']
@@ -380,12 +377,16 @@ def get_stator_dimensions(par, slots=[]):
             middle_line=0 if layers < 2 else middle_line))
     # coils per phase and pole
     # q = Q/2/p/m
-    # num wires per coil side
+    # num wires per coil side (number of coil groups a)
     # n = a*N / 2 / p / q
-    num_wires = round(2*m*N/layers/Q1)
+    ncoils = Q1//2//m*layers
+    ngroups = [1] + [g for g in range(2, p+1) if p%g == 0]
+    a = ngroups[np.argmin([abs(N-ncoils//a*round(a*N/ncoils))
+                           for a in ngroups])]
+    num_wires = round(a*N/ncoils)
     dwire = 2*np.sqrt(ans*kq/layers/np.pi/num_wires)
     relculen = 1.4
-    r1 = wdg_resistance(N, relculen*lfe, dwire)
+    r1 = wdg_resistance(N, relculen*lfe, dwire)/a
     r['pcu'] = round(m*r1*I1**2, 1)
 
     r['winding'] = dict(
@@ -393,6 +394,7 @@ def get_stator_dimensions(par, slots=[]):
         num_phases=m,
         cufilfact=kq,
         culength=1.4,
+        num_par_wdgs=a,
         num_layers=layers,
         resistance=round(r1, 4),
         coil_span=int(coil_span),
@@ -662,6 +664,7 @@ def spm(pnom: float, speed: float, p: int, **kwargs) -> dict:
     par.update(kwargs)
 
     _set_pm_defaults(par)
+
     # stator and magnet parameters of surface mounted magnet machine
     r = get_stator_dimensions(par)
 

femagtools/machine/sm.py

@@ -45,6 +45,9 @@ def parident(workdir, engine, machine,
         num_exc_steps: number of excitation current (default 7)
         speed: rotor speed in 1/s (default 160/p)
         i1_max: maximum current in A rms (default approx 3*i1nom)
+        beta_min: minimal current angle (default -180°)
+        beta_max: maximal current angle (default 0°)
+        num_move_steps: number of move steps 
         """
         cmd = kwargs.get('cmd', None)
         da1 = machine['outer_diam']
@@ -60,7 +63,7 @@ def parident(workdir, engine, machine,
         N = machine[wdgk]['num_wires']
         i1_max = round(0.28*np.pi*hs*(da1+hs)/Q1/N*Jmax*1e5)*10 * \
             machine[wdgk].get('num_par_wdgs', 1)
-        
+
         ifnom = machine['rotor']['ifnom']
         exc_logspace = True
         if exc_logspace:
@@ -86,22 +89,21 @@ def parident(workdir, engine, machine,
                                            'ld_lq_fast'),
                 wind_temp=20.0,
                 i1_max=kwargs.get('i1_max', i1_max),
-                maxid=0,
-                minid=-i1_max,
-                maxiq=i1_max,
-                miniq=-i1_max,
-                delta_id=i1_max/kwargs.get('num_cur_steps', 5),
-                delta_iq=i1_max/kwargs.get('num_cur_steps', 5),
-                beta_min=-180.0,
-                beta_max=0.0,
-                calc_noload=0,
+                maxid=kwargs.get('maxid', 0),
+                minid=kwargs.get('minid', -i1_max),
+                maxiq=kwargs.get('maxiq', i1_max),
+                miniq=kwargs.get('miniq', -i1_max),
+                delta_id=kwargs.get('delta_id', i1_max/5),
+                delta_iq=kwargs.get('delta_iq', i1_max/5),
+                beta_min=kwargs.get('beta_min', -180),
+                beta_max=kwargs.get('beta_max', 0),
                 num_move_steps=kwargs.get('num_move_steps', 31),
                 load_ex_cur=0.5,
                 num_cur_steps=kwargs.get('num_cur_steps', 5),
                 num_beta_steps=kwargs.get('num_beta_steps', 13),
                 num_par_wdgs=machine[wdgk].get('num_par_wdgs', 1),
-                period_frac=6,
-                speed=50.0)
+                period_frac=kwargs.get('period_frac', 6),
+                speed=kwargs.get('speed', 50))
 
         ###self.cleanup()  # remove previously created files in workdir
         results = parvar(parvardef, machine, simulation, engine)
@@ -119,9 +121,10 @@ def parident(workdir, engine, machine,
             rotor_mass = 0  # need femag classic > rel-9.3.x-48-gca42bbd0
         b = results['f'][-1]
 
-        losskeys = ('speed', 'ef', 'hf',
+        losskeys = ('speed', 'ef', 'hf', 'cf', 
                     'styoke_hyst', 'stteeth_hyst', 'styoke_eddy',
-                    'stteeth_eddy', 'rotor_hyst', 'rotor_eddy')
+                    'stteeth_eddy', 'rotor_hyst', 'rotor_eddy',
+                    'styoke_excess', 'stteeth_excess', 'rotor_excess')
 
         # winding resistance
         try:
@@ -159,7 +162,7 @@ def parident(workdir, engine, machine,
                                 ld=b['ldq']['ld'],
                                 lq=b['ldq']['lq'],
                                 losses={k: b['ldq']['losses'][k]
-                                        for k in losskeys})
+                                        for k in losskeys if k in b['ldq']['losses']})
                              for b in results['f']])
         else:
                 dqpars = dict(m=3, p=b['machine']['p'],
@@ -170,11 +173,12 @@ def parident(workdir, engine, machine,
                             ex_current=b['machine']['ex_current'],
                             iq=b['psidq']['iq'],
                             id=b['psidq']['id'],
+                            psidq_ldq=b['psidq_ldq'],
                             psid=b['psidq']['psid'],
                             psiq=b['psidq']['psiq'],
                             torque=b['psidq']['torque'],
                             losses={k: b['psidq']['losses'][k]
-                                    for k in losskeys})
+                                    for k in losskeys if k in b['psidq']['losses']})
                            for b in results['f']])
         if 'current_angles' in results['f'][0]:
                 dqpars['current_angles'] = results['f'][0]['current_angles']
@@ -242,6 +246,7 @@ class SynchronousMachine(object):
         self.kth2 = KTH
         self.skin_resistance = [None, None]
         self.kpmag = 1
+        self.bertotti = False
         # here you can set user defined functions for calculating the skin-resistance,
         # according to the current frequency w. First function in list is for stator, second for rotor.
         # If None, the femagtools intern default implementation is used.
@@ -282,6 +287,13 @@ class SynchronousMachine(object):
                       'rotor_hyst': hf,
                       'rotor_eddy': ef}
 
+        if self.bertotti:
+            self.plexp.update({
+                        'styoke_excess': 1.5,
+                        'stteeth_excess':1.5,
+                        'rotor_excess': 1.5})
+            
+
     def pfric(self, n):
         """friction and windage losses"""
         return 2*np.pi*n*self.tfric
@@ -315,7 +327,7 @@ class SynchronousMachine(object):
         if n > 1e-3:
             f1 = self.p*n
             plfe = self.kpfe * (self.iqd_plfe1(iq, id, iex, f1)
-                                + self.iqd_plfe2(iq, id, f1))
+                                + self.iqd_plfe2(iq, id, iex, f1))
             return (plfe + self.pfric(n))/(2*np.pi*n)
         return 0
 
@@ -341,7 +353,7 @@ class SynchronousMachine(object):
         """return uq, ud of frequency w1 and d-q current"""
         psid, psiq = self.psi(iq, id, iex)
         r1 = self.rstat(w1)
-        return r1*id + w1*psid, r1*iq - w1*psiq
+        return r1*iq + w1*psid, r1*id - w1*psiq
 
     def plcu1(self, iqde, w1):
         r1 = self.rstat(w1)
@@ -360,7 +372,7 @@ class SynchronousMachine(object):
     def iqd_plcu2(self, iq, id, iex):
         return self.plcu2((iq, id, iex))
 
-    def iqd_plfe2(self, iq, id, f1):
+    def iqd_plfe2_(self, iq, id, f1):
         return np.zeros(np.asarray(iq).shape)
 
     def iqd_plmag(self, iq, id, f1):
@@ -369,9 +381,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], 0, sum(self.bounds[-1])
+            startvals = self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
         else:
-            startvals = -self.bounds[0][1], 0, sum(self.bounds[-1])
+            startvals = -self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -398,9 +410,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], 0, sum(self.bounds[-1])
+            startvals = self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
         else:
-            startvals = -self.bounds[0][1], 0, sum(self.bounds[-1])
+            startvals = -self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -425,7 +437,7 @@ class SynchronousMachine(object):
 
     def mtpa(self, i1max):
         """return iq, id, iex currents and maximum torque per current """
-        T0 = self.torque_iqd(np.sqrt(2)*i1max, 0, self.bounds[-1][1])
+        T0 = self.torque_iqd(np.sqrt(2)*i1max/2, 0, self.bounds[-1][1]/2)
         def i1tq(tq):
             return abs(i1max) - np.linalg.norm(self.iqd_torque(tq)[:2])/np.sqrt(2)
         with warnings.catch_warnings():
@@ -436,7 +448,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, 0, self.bounds[-1][0])
+        T0 = self.torque_iqd(np.sqrt(2)*i1max/2, 0, self.bounds[-1][0])/2
         def i1tq(tq):
             return i1max - np.linalg.norm(self.iqd_tmech(tq, n)[:2])/np.sqrt(2)
         tq = so.fsolve(i1tq, T0)[0]
@@ -560,7 +572,11 @@ class SynchronousMachine(object):
         nsamples -- (optional) number of speed samples
         with_tmech -- (optional) use friction and windage losses
         with_torque_corr -- (optional) T is corrected if out of range
+        Optional arguments:
+        i1max: max. phase current (RMS)
         """
+        if kwargs.get('i1max', 0):
+                w1type, T = self.w1_imax_umax(kwargs['i1max'], u1max)
         try:
             iq, id, iex = self.iqd_torque(T)
         except ValueError:
@@ -588,6 +604,7 @@ class SynchronousMachine(object):
             if T < 0:
                 i1max = -i1max
             w1type, Tf = self.w1_imax_umax(i1max, u1max)
+
         else:
             Tf = T
             w1type = self.w1_umax(u1max, iq, id, iex)
@@ -619,7 +636,9 @@ class SynchronousMachine(object):
         wmtab[0] = 0
 
         r = dict(u1=[], i1=[], id=[], iq=[], iex=[], T=[], cosphi=[], n=[],
-                 beta=[], plfe1=[], plcu1=[], plcu2=[])
+                 beta=[], plfe1=[], plfe2=[], plcu1=[], plcu2=[])
+        # add type speed to result dict
+        r['n_type'] = wmType/2/np.pi
         for wm, tq in zip(wmtab, [tload(wx) for wx in wmtab]):
             w1 = wm*self.p
             if with_tmech:
@@ -645,12 +664,13 @@ class SynchronousMachine(object):
             gamma = np.arctan2(ud, uq)
             r['cosphi'].append(np.cos(gamma - beta))
             r['plfe1'].append(self.iqd_plfe1(iq, id, iex, f1))
+            r['plfe2'].append(self.iqd_plfe2(iq, id, iex, f1))
             r['plcu1'].append(self.m*i1**2*self.rstat(w1))
             r['plcu2'].append(iex**2*self.rrot(0))
             r['T'].append(tqx)
             r['n'].append(wm/2/np.pi)
 
-        r['plfe'] = r['plfe1']
+        r['plfe'] = (np.array(r['plfe1']) + np.array(r['plfe2'])).tolist()
         r['plcu'] = (np.array(r['plcu1']) + np.array(r['plcu2'])).tolist()
         r['plfw'] = [self.pfric(n) for n in r['n']]
         r['pmech'] = [2*np.pi*n*tq
@@ -685,6 +705,10 @@ class SynchronousMachinePsidq(SynchronousMachine):
                         eecpars['psidq'][0]['iq'][-1])
         self.idrange = (eecpars['psidq'][0]['id'][0],
                         eecpars['psidq'][0]['id'][-1])
+        
+        self.betarange = (-np.pi if min(self.iqrange) < 0 else -np.pi/2,
+                          0 if max(self.iqrange) > 0 else -np.pi/2)
+        self.i1range = (0, betai1(np.max(self.iqrange), 0)[1])
         islinear = True
         iexc = [l['ex_current'] for l in eecpars['psidq']]
         self.exc_max = iexc[-1]
@@ -722,9 +746,18 @@ class SynchronousMachinePsidq(SynchronousMachine):
         self.bounds = [(min(iq), max(iq)),
                        (min(id), 0),
                        (iexc[0], iexc[-1])]
+        
+        keys = self.plexp.keys()
         try:
             idname = 'psidq'
-            keys = self.plexp.keys()
+            # check if bertotti 
+            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}})
             if islinear:
                 pfe = {k: np.array([l['losses'][k]
                                     for l in eecpars[idname]])
@@ -758,14 +791,27 @@ class SynchronousMachinePsidq(SynchronousMachine):
             raise ex
 
     def plfe1(self, iq, id, iex, f1):
+        losskeys = ['styoke_eddy', 'styoke_hyst',
+                      'stteeth_eddy', 'stteeth_hyst']
+        if self.bertotti: 
+            losskeys += ['styoke_excess', 'stteeth_excess']
+        return np.sum([
+            self._losses[k]((iex, iq, id))*(f1/self.fo)**self.plexp[k][0]
+            for k in losskeys], axis=0)
+    
+    def plfe2(self, iq, id, iex, f1):
+        losskeys = ['rotor_hyst', 'rotor_eddy']
+        if self.bertotti: 
+            losskeys += ['rotor_excess']
         return np.sum([
             self._losses[k]((iex, iq, id))*(f1/self.fo)**self.plexp[k][0]
-            for k in ('styoke_eddy', 'styoke_hyst',
-                      'stteeth_eddy', 'stteeth_hyst')], axis=0)
+            for k in losskeys], axis=0)
 
     def iqd_plfe1(self, iq, id, iex, f1):
         return self.plfe1(iq, id, iex, f1)
 
+    def iqd_plfe2(self, iq, id, iex, f1): 
+        return self.plfe2(iq, id, iex, f1)
 
 class SynchronousMachineLdq(SynchronousMachine):
     def __init__(self, eecpars, lfe=1, wdg=1, **kwargs):
@@ -814,9 +860,20 @@ class SynchronousMachineLdq(SynchronousMachine):
         self.bounds = [(np.cos(min(beta))*i1max, i1max),
                        (-i1max, 0),
                        (iexc[0], iexc[-1])]
+
+        # iron losses 
         keys = self.plexp.keys()
         try:
             idname = 'ldq'
+            # check bertotti losses
+            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}})
+
             if islinear:
                 pfe = {k: np.array([l['losses'][k]
                                     for l in eecpars[idname]])
@@ -826,6 +883,7 @@ class SynchronousMachineLdq(SynchronousMachine):
                                     np.array([l['losses'][k]
                                              for l in eecpars[idname]]))
                        for k in keys}
+
         # fill value with nan outside range
             self._losses = {k: ip.RegularGridInterpolator(
                     (exc, beta, i1), lfe*np.array(pfe[k]),
@@ -834,12 +892,13 @@ class SynchronousMachineLdq(SynchronousMachine):
             self._set_losspar(eecpars[idname][0]['losses']['speed'],
                               eecpars[idname][0]['losses']['ef'],
                               eecpars[idname][0]['losses']['hf'])
-        except ValueError:
+        except KeyError:
             logger.warning("loss map missing")
             self._losses = {k: lambda x: 0 for k in (
                 'styoke_hyst', 'stteeth_hyst',
                 'styoke_eddy', 'stteeth_eddy',
                 'rotor_hyst', 'rotor_eddy')}
+            pass
 
     def psi(self, iq, id, iex):
         """return psid, psiq of currents iq, id"""
@@ -855,10 +914,22 @@ class SynchronousMachineLdq(SynchronousMachine):
             raise ex
 
     def plfe1(self, beta, i1, iex, f1):
+        losskeys =  ['styoke_eddy', 'styoke_hyst',
+                      'stteeth_eddy', 'stteeth_hyst']
+        if self.bertotti: 
+            losskeys += ['styoke_excess', 'stteeth_excess']
+        return np.sum([
+            self._losses[k]((iex, beta, i1))*(f1/self.fo)**self.plexp[k][0]
+            for k in losskeys], axis=0)
+    
+    def plfe2(self, beta, i1, iex, f1):
+        losskeys =  ['rotor_hyst', 'rotor_eddy']
+        if self.bertotti: 
+            losskeys += ['rotor_excess']
         return np.sum([
             self._losses[k]((iex, beta, i1))*(f1/self.fo)**self.plexp[k][0]
-            for k in ('styoke_eddy', 'styoke_hyst',
-                      'stteeth_eddy', 'stteeth_hyst')], axis=0)
+            for k in losskeys], axis=0)
+    
     def iqd_plfe1(self, iq, id, iex, f1):
         beta = np.arctan2(id, iq)
         if np.isscalar(beta):
@@ -869,6 +940,16 @@ class SynchronousMachineLdq(SynchronousMachine):
         i1 = np.linalg.norm((id, iq), axis=0)/np.sqrt(2.0)
         return self.plfe1(beta, i1, iex, f1)
 
+    def iqd_plfe2(self, iq, id, iex, f1):
+        beta = np.arctan2(id, iq)
+        if np.isscalar(beta):
+            if beta > 0:
+                beta -= 2*np.pi
+        else:
+            beta[beta > 0] -= 2*np.pi
+        i1 = np.linalg.norm((id, iq), axis=0)/np.sqrt(2.0)
+        return self.plfe2(beta, i1, iex, f1)
+
 
 if __name__ == '__main__':
     import sys

femagtools/machine/utils.py

@@ -166,15 +166,15 @@ def wdg_leakage_inductances(machine):
     Juha Pyrhönen, Tapani Jokinen, Valeria Hrabovcova
     (Ed. 2008) page 236ff
     """
-    from ..windings import Winding
-    wdg = Winding(
+    wdgk = 'windings' if 'windings' in machine else 'winding'
+    wdg = windings.Winding(
         {'Q': machine['stator']['num_slots'],
-         'm': machine['windings']['num_phases'],
+         'm': machine[wdgk]['num_phases'],
          'p': machine['poles']//2,
-         'l': machine['windings']['num_layers'],
-         'yd': machine['windings']['coil_span']})
-    n1 = wdg.turns_per_phase(machine['windings']['num_wires'],
-                             machine['windings']['num_par_wdgs'])
+         'l': machine[wdgk]['num_layers'],
+         'yd': machine[wdgk]['coil_span']})
+    n1 = wdg.turns_per_phase(machine[wdgk]['num_wires'],
+                             machine[wdgk]['num_par_wdgs'])
     m = wdg.m
     p = wdg.p
     Q = wdg.Q
@@ -218,6 +218,20 @@ def wdg_leakage_inductances(machine):
     return Lu, Lew
 
 
+def create_wdg(machine):
+    """create winding from machine parameters"""
+    wdgk = 'windings' if 'windings' in machine else 'winding'
+    wpar = {'Q': machine['stator']['num_slots'],
+            'm': machine[wdgk]['num_phases'],
+            'p': machine['poles']//2}
+
+    if 'coil_span' in machine[wdgk]:
+        wpar['yd'] = machine[wdgk]['coil_span']
+    if 'num_layers' in machine[wdgk]:
+        wpar['l'] = machine[wdgk]['num_layers']
+    return windings.Winding(wpar)
+
+
 def betai1(iq, id):
     """return beta and amplitude of dq currents"""
     return (np.arctan2(id, iq),
@@ -352,18 +366,6 @@ def dqparident(workdir, engine, temp, machine,
     """
     import pathlib
 
-    wdgk = 'windings' if 'windings' in machine else 'winding'
-    def create_wdg(machine):
-        wpar = {'Q': machine['stator']['num_slots'],
-                'm': machine[wdgk]['num_phases'],
-                'p': machine['poles']//2}
-
-        if 'coil_span' in machine[wdgk]:
-            wpar['yd'] = machine[wdgk]['coil_span']
-        if 'num_layers' in machine[wdgk]:
-            wpar['l'] = machine[wdgk]['num_layers']
-
-        return windings.Winding(wpar)
     try:
         defspeed = 160/machine['poles']
     except KeyError:
@@ -372,6 +374,7 @@ def dqparident(workdir, engine, temp, machine,
         defspeed = kwargs['speed']
 
     lfe = machine['lfe']
+    wdgk = 'windings' if 'windings' in machine else 'winding'
     g = machine[wdgk].get('num_par_wdgs', 1)
     N = machine[wdgk]['num_wires']
     if 'cufilfact' in machine[wdgk]:
@@ -382,21 +385,22 @@ def dqparident(workdir, engine, temp, machine,
         fcu = 0.42
 
     try: # calc basic dimensions if not fsl or dxf model
-        Q1 = machine['stator']['num_slots']
-        da1 = machine['bore_diam']
+        wdg = create_wdg(machine)
+        Q1 = wdg.Q
         slotmodel = [k for k in machine['stator'] if isinstance(
             machine['stator'][k], dict)][-1]
         if slotmodel == 'stator1':
             hs = machine['stator']['stator1']['slot_rf1'] - \
                 machine['stator']['stator1']['tip_rh1']
         else:
+            da1 = machine['bore_diam']
             dy1 = machine['outer_diam']
             hs = machine['stator'][slotmodel].get(
                 'slot_height', 0.6*(dy1-da1)/2)
 
         Jmax = 30e6  # max current density in A/m2
-        Acu = fcu*0.5*np.pi*(da1+hs)*hs
-        i1_max = round(Acu/Q1/N*Jmax/10)*10
+        Acu = fcu*np.pi*(da1+hs)*hs/Q1/2  # approx. copper area of one slot
+        i1_max = round(g*Acu/wdg.l/N*Jmax/10)*10
     except KeyError:
         if kwargs.get('i1_max', 0) == 0:
             raise ValueError('i1_max missing')
@@ -404,14 +408,12 @@ def dqparident(workdir, engine, temp, machine,
 
     # winding resistance
     try:
-        wdg = create_wdg(machine)
-
         if 'wire_gauge' in machine[wdgk]:
             aw = machine[wdgk]['wire_gauge']
         elif 'dia_wire' in machine[wdgk]:
             aw = np.pi*machine[wdgk].get('dia_wire', 1e-3)**2/4
         elif ('wire_width' in machine[wdgk]) and ('wire_height' in machine[wdgk]):
-            aw = machine['windings']['wire_width']*machine[wdgk]['wire_height']
+            aw = machine[wdgk]['wire_width']*machine[wdgk]['wire_height']
         else:  # wire diameter from slot area
             aw = 0.75 * fcu * np.pi*da1*hs/Q1/wdg.l/N
         r1 = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
@@ -456,12 +458,10 @@ def dqparident(workdir, engine, temp, machine,
     # TODO: cleanup()  # remove previously created files in workdir
     # start calculation
     results = parvar(parvardef, machine, simulation, engine)
-    if 'poles' not in machine:
+    if 'poles' not in machine:  # dxf model?
         machine['poles'] = 2*results['f'][0]['machine']['p']
         da1 = 2*results['f'][0]['machine']['fc_radius']
-    #import json
-    #with open('results.json', 'w') as fp:
-    #    json.dump(results, fp)
+        wdg = create_wdg(machine)
     ls1 = 0
     try:
         leakages = [float(x)
@@ -522,13 +522,17 @@ def dqparident(workdir, engine, temp, machine,
         else:
             from .. import nc
             model = nc.read(str(pathlib.Path(workdir) / machine['name']))
-            Q1 = model.num_slots
-            #machine['stator']['num_slots'] = Q1
-            wdg = create_wdg(machine)
+            try:
+                nlayers = wdg.l
+            except UnboundLocalError:
+                wdg = create_wdg(machine)
+                nlayers = wdg.l
+                da1 = machine['outer_diam']
+            Q1 = wdg.Q
             istat = 0 if model.get_areas()[0]['slots'] else 1
             asl = model.get_areas()[istat]['slots']
             # diameter of wires
-            aw = fcu*asl/Q1/wdg.l/N
+            aw = fcu*asl/Q1/nlayers/N
             hs = asl/(np.pi*da1/3)
             dqpars['r1'] = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
 

femagtools/model.py

@@ -65,7 +65,7 @@ class Model(object):
         """return value of key name
 
         Args:
-            name: key of parameter value
+            name (str or list of str): key of parameter value
 
         Return:
             value of parameter identified by key
@@ -214,7 +214,7 @@ class MachineModel(Model):
             logging.debug(slotgen)
             g = np.gcd.reduce(slotgen)
             if hasattr(self, 'magnet') and g > 1:
-                g /= m
+                g //= m
             if 'num_slots' in self.stator:
                 Q1 = self.stator['num_slots']
                 self.stator['num_slots_gen'] = Q1 // g
@@ -415,6 +415,16 @@ class MachineModel(Model):
     def has_magnet(self):  # either rotor or magnet
         return hasattr(self, 'magnet')
 
+    def props(self):
+        """returns dict of this model"""
+        keys = ('name', 'poles', 'outer_diam', 'airgap',
+                'bore_diam', 'external_rotor', 'agndst')
+        model = {k: getattr(self, k) for k in keys if hasattr(self, k)}
+        if hasattr(self, 'stator'):
+            model['stator'] = {k: self.stator[k]
+                               for k in ('num_slots', 'num_slots_gen')
+                               if k in self.stator}
+        return model
 
 class FeaModel(Model):
     """represents a simulation model for a FE analysis"""

femagtools/moo/population.py

@@ -1,5 +1,5 @@
 """
-  Copyright (c) 2015 Semafor Informatik & Energie AG
+  Population
 
 """
 import sys

femagtools/parstudy.py

@@ -188,6 +188,9 @@ class ParameterStudy(object):
         simulation.update(model.winding)
         if 'pocfilename' not in simulation:
             simulation['pocfilename'] = f"{model.name}.poc"
+        if simulation['calculationMode'] == 'psd_psq_fast':
+            simulation['pocfilename'] = f"{model.name}_{model.get('poles')}p.poc"
+
         fea = femagtools.model.FeaModel(simulation)
 
         prob = femagtools.moproblem.FemagMoProblem(decision_vars,
@@ -196,7 +199,20 @@ class ParameterStudy(object):
         if immutable_model:
             modelfiles = self.setup_model(builder, model, recsin=fea.recsin)
             logger.info("Files %s", modelfiles+extra_files)
-
+            logger.info("model %s", model.props())
+            for k in ('name', 'poles', 'outer_diam', 'airgap', 'bore_diam',
+                      'external_rotor'):
+                if k not in machine:
+                    try:
+                        machine[k] = model.get(k)
+                    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
         job = engine.create_job(self.femag.workdir)
         # for progress logger
         job.num_cur_steps = fea.get_num_cur_steps()

femagtools/plot/__init__.py

@@ -10,7 +10,7 @@ from .bch import torque, torque_fft, force, force_fft, \
     i1beta_psiq, i1beta_psim, i1beta_up, \
     idq_ld, idq_lq, idq_psid, idq_psim, idq_psiq, idq_torque
 from .char import mtpa, mtpv, characteristics, efficiency_map, losses_map
-from .forcedens import forcedens, forcedens_surface, forcedens_fft
+from .forcedens import forcedens, forcedens_surface, forcedens_contour, forcedens_fft
 from .nc import spel, mesh, demag, demag_pos, \
     flux_density, flux_density_eccentricity, \
     airgap_flux_density_pos, loss_density