femagtools 1.5.7__py3-none-any.whl → 1.6.1__py3-none-any.whl

femagtools/machine/afpm.py

@@ -45,7 +45,7 @@ def ld_interpol(i1, beta, v):
     cur = copy.deepcopy(i1)
     betad = copy.deepcopy(beta)
     if np.amin(beta) < -90 and \
-        np.amax(beta) > -90: 
+        np.amax(beta) > -90:
         # motor and generator
         v[0] = v[1]
         v[-1] = v[-2]
@@ -53,18 +53,18 @@ def ld_interpol(i1, beta, v):
         dbeta = np.abs(beta[0][0] - beta[1][0])
         bp = [[beta[0][0]-dbeta for i in range(len(np.unique(i1)))]] + beta[1:-1] + \
             [[dbeta for i in range(len(np.unique(i1)))]]
-    else: 
+    else:
         v[-1] = v[-2]
         dbeta = np.abs(beta[0][0] - beta[1][0])
         bp = beta[0:-1] + \
             [[dbeta for i in range(len(np.unique(i1)))]]
-    
+
     return RectBivariateSpline(np.unique(bp), np.unique(cur), \
          np.array(v)).ev(*[betad, i1]).tolist()
 
 def lq_interpol(i1, beta, v):
     '''interpolate Lq at beta -90°'''
-    if -90 not in np.unique(beta): 
+    if -90 not in np.unique(beta):
         return v
     # lq
     betad = copy.deepcopy(beta)
@@ -75,7 +75,7 @@ def lq_interpol(i1, beta, v):
         v.pop(inx[0, 0])
         bp = beta[0:inx[0, 0]] + beta[inx[0, 0]+1:]
         cp = i1[0:inx[0, 0]] + i1[inx[0, 0]+1:]
-    else: 
+    else:
         v[0] = v[1]
         dbeta = np.abs(beta[0][0] - beta[1][0])
         bp = [[-90-dbeta for i in i1[0]]] + beta[1::]
@@ -181,7 +181,7 @@ def parident(workdir, engine, temp, machine,
             poc=poc.Poc(999),
             speed=0)
         logging.info("Noload simulation")
-        if kwargs.get('use_multiprocessing', True): 
+        if kwargs.get('use_multiprocessing', True):
             pstudy = parstudy.List(
                     workdir, condMat=condMat, magnets=magnetMat,
                     magnetizingCurves=magnetizingCurves,
@@ -190,17 +190,17 @@ 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'])
-        else: 
+        else:
             nlresults = {"x": [], "f": []}
             i = 0
-            for pw, le, sp in zip(pole_width, lfe, linspeed): 
+            for pw, le, sp in zip(pole_width, lfe, linspeed):
                 nlmachine = {k: machine[k] for k in machine}
                 nlmachine['pole_width'] = pw
                 nlmachine['lfe'] = le
                 nlcalc.update({"speed": sp})
                 nlsubdir = f'{workdir}/{i}'
                 nlworkdir = Path(nlsubdir)
-                if nlworkdir.exists(): 
+                if nlworkdir.exists():
                     shutil.rmtree(nlworkdir)
                 nlworkdir.mkdir(exist_ok=True)
                 noloadsim = femag.Femag(nlworkdir, condMat=condMat, magnets=magnetMat,
@@ -235,8 +235,8 @@ def parident(workdir, engine, temp, machine,
                 num_move_steps=60,
                 speed=linspeed[i],
                 num_par_wdgs=machine[wdgk].get('num_par_wdgs', 1))
-            
-            if kwargs.get('use_multiprocessing', True): 
+
+            if kwargs.get('use_multiprocessing', True):
                 gpstudy = parstudy.Grid(
                                     subdir, condMat=condMat, magnets=magnetMat,
                                     magnetizingCurves=magnetizingCurves,
@@ -248,7 +248,7 @@ def parident(workdir, engine, temp, machine,
                 domain_beta = np.linspace(beta_min, 0, num_beta_steps).tolist()
                 domain_cur = np.linspace(i1_max/num_cur_steps, i1_max, num_cur_steps).tolist()
                 dir_index = 0
-                for cur in domain_cur: 
+                for cur in domain_cur:
                     for be in domain_beta:
                         simulation['angl_i_up'] = be
                         simulation['current'] = cur
@@ -256,7 +256,7 @@ def parident(workdir, engine, temp, machine,
                         subsubdir = subdir + f'/{dir_index}'
                         dir_index = dir_index + 1
                         lworkdir = Path(subsubdir)
-                        if lworkdir.exists(): 
+                        if lworkdir.exists():
                             shutil.rmtree(lworkdir)
                         lworkdir.mkdir(exist_ok=True)
                         loadsim = femag.Femag(lworkdir, condMat=condMat, magnets=magnetMat,
@@ -264,7 +264,7 @@ def parident(workdir, engine, temp, machine,
                                             cmd=kwargs.get('cmd', None))
                         r = loadsim(mpart, simulation)
                         lresults['f'].append({k: v for k, v in r.items()})
-                        
+
             f = [{k: bch[k]
                   for k in ('linearForce', 'flux', 'losses', 'lossPar')}
                  for bch in lresults['f']]
@@ -288,18 +288,18 @@ def parident(workdir, engine, temp, machine,
                           (-1, num_beta_steps)).T/np.sqrt(2)
         psiq = np.reshape([r['psiq'] for r in postp],
                           (-1, num_beta_steps)).T/np.sqrt(2)
-        
+
         ld = np.reshape([r['Ld'] for r in postp],
                           (-1, num_beta_steps)).T.tolist()
         lq = np.reshape([r['Lq'] for r in postp],
                           (-1, num_beta_steps)).T.tolist()
         # interpolation ld, lq
-        curr, angl = [], [] 
-        for cr in range(len(beta)): 
+        curr, angl = [], []
+        for cr in range(len(beta)):
             curr.append(i1)
-        for al in beta: 
+        for al in beta:
             tmp = []
-            for cr in range(len(i1)): 
+            for cr in range(len(i1)):
                 tmp.append(al)
             angl.append(tmp)
         try:
@@ -307,10 +307,10 @@ def parident(workdir, engine, temp, machine,
             ld = ld_interpol(xx, yy, ld)
             xx, yy = copy.deepcopy(curr), copy.deepcopy(angl)
             lq = lq_interpol(xx, yy, lq)
-        except: 
+        except:
             ld = np.zeros_like(psid).tolist()
             lq = np.zeros_like(psid).tolist()
-        
+
         torque = np.reshape([r['torque'] for r in postp],
                             (-1, num_beta_steps)).T
         losses = {k: np.flip(np.reshape([r['plfe'][k] for r in postp],
@@ -547,6 +547,7 @@ def wdg_resistance(wdg, n, g, aw, outer_diam, inner_diam,
 def _get_copper_losses(scale_factor, bch):
     """return copper losses from bch files"""
     try:
+        wdgk = 'winding'
         cu_losses = sum([b['losses'][0][wdgk] for b in bch])
         return scale_factor*cu_losses
     except KeyError:

femagtools/machine/pm.py

@@ -638,10 +638,10 @@ class PmRelMachine(object):
                       'rotor_hyst': hf[1],
                       'rotor_eddy': ef[1]}
         #                          'magnet'):
-        if 'styoke_exc' in pfe:
-            self.plexp.update({'styoke_exc': cf[0],
-                               'stteeth_exc':cf[0],
-                               'rotor_exc': cf[1]})
+        if 'styoke_excess' in pfe:
+            self.plexp.update({'styoke_excess': cf[0],
+                               'stteeth_excess':cf[0],
+                               'rotor_excess': cf[1]})
 
     def betai1_plcu(self, i1, w1=0):
         return self.m*self.rstat(w1)*i1**2
@@ -1143,15 +1143,16 @@ class PmRelMachineLdq(PmRelMachine):
             kx = len(beta)-1
         try:
             pfe = kwargs['losses']
-            if 'styoke_exc' in pfe:
+            if 'styoke_excess' in pfe and np.any(pfe['styoke_excess']):
                 self.bertotti = True
-                self.losskeys += ['styoke_exc',
-                                  'stteeth_exc',
-                                  'rotor_exc']
+                self.losskeys += ['styoke_excess',
+                                  'stteeth_excess',
+                                  'rotor_excess']
             self._set_losspar(pfe)
             self._losses = {k: ip.RectBivariateSpline(
                 beta, i1, np.array(pfe[k]),
-                kx=kx, ky=ky).ev for k in tuple(self.losskeys)}
+                kx=kx, ky=ky).ev for k in self.losskeys
+                            if k in pfe}
         except KeyError as e:
             logger.warning("loss map missing: %s", e)
             pass
@@ -1238,12 +1239,12 @@ class PmRelMachineLdq(PmRelMachine):
 
     def betai1_plfe1(self, beta, i1, f1):
         stator_losskeys = ['styoke_eddy', 'styoke_hyst',
-                            'stteeth_eddy', 'stteeth_hyst']
+                           'stteeth_eddy', 'stteeth_hyst']
         if self.bertotti:
-            stator_losskeys += ['styoke_exc', 'stteeth_exc']
+            stator_losskeys += ['styoke_excess', 'stteeth_excess']
         return np.sum([
-            self._losses[k](beta, i1)*(f1/self.fo)**self.plexp[k] for
-            k in tuple(stator_losskeys)], axis=0)
+            self._losses[k](beta, i1)*(f1/self.fo)**self.plexp[k]
+            for k in stator_losskeys if k in self._losses], axis=0)
 
     def iqd_plfe1(self, iq, id, f1):
         return self.betai1_plfe1(*betai1(iq, id), f1)
@@ -1251,7 +1252,7 @@ class PmRelMachineLdq(PmRelMachine):
     def betai1_plfe2(self, beta, i1, f1):
         rotor_losskeys = ['rotor_eddy', 'rotor_hyst']
         if self.bertotti:
-            rotor_losskeys += ['rotor_exc']
+            rotor_losskeys += ['rotor_excess']
         return np.sum([
             self._losses[k](beta, i1)*(f1/self.fo)**self.plexp[k] for
             k in tuple(rotor_losskeys)], axis=0)
@@ -1295,7 +1296,7 @@ class PmRelMachinePsidq(PmRelMachine):
         self.iqrange = (min(iq), max(iq))
         self.betarange = (-np.pi if min(iq) < 0 else -np.pi/2,
                           0 if max(iq) > 0 else -np.pi/2)
-        self.i1range = (0, np.sqrt(2)*np.min(id))
+        self.i1range = (0, betai1(np.max(iq), 0)[1])
         self.io = np.max(iq)/2, np.min(id)/2
 
         if np.any(psid.shape < (4, 4)):
@@ -1322,11 +1323,11 @@ class PmRelMachinePsidq(PmRelMachine):
         self._psiq = ip.RectBivariateSpline(iq, id, psiq).ev
         try:
             pfe = kwargs['losses']
-            if 'styoke_exc' in pfe:
+            if 'styoke_excess' in pfe and np.any(pfe['styoke_excess']):
                 self.bertotti = True
-                self.losskeys += ['styoke_exc',
-                                  'stteeth_exc',
-                                  'rotor_exc']
+                self.losskeys += ['styoke_excess',
+                                  'stteeth_excess',
+                                  'rotor_excess']
             self._set_losspar(pfe)
             self._losses = {k: ip.RectBivariateSpline(
                 iq, id, np.array(pfe[k])).ev for k in (
@@ -1385,7 +1386,7 @@ class PmRelMachinePsidq(PmRelMachine):
         stator_losskeys = ['styoke_eddy', 'styoke_hyst',
                             'stteeth_eddy', 'stteeth_hyst']
         if self.bertotti:
-            stator_losskeys += ['styoke_exc', 'stteeth_exc']
+            stator_losskeys += ['styoke_excess', 'stteeth_excess']
         return np.sum([
             self._losses[k](iq, id)*(f1/self.fo)**self.plexp[k] for
             k in tuple(stator_losskeys)], axis=0)
@@ -1396,7 +1397,7 @@ class PmRelMachinePsidq(PmRelMachine):
     def iqd_plfe2(self, iq, id, f1):
         rotor_losskeys = ['rotor_eddy', 'rotor_hyst']
         if self.bertotti:
-            rotor_losskeys += ['rotor_exc']
+            rotor_losskeys += ['rotor_excess']
         return np.sum([
             self._losses[k](iq, id)*(f1/self.fo)**self.plexp[k] for
             k in tuple(rotor_losskeys)], axis=0)

femagtools/machine/sm.py

@@ -546,7 +546,7 @@ class SynchronousMachine(object):
             w10)[0]
 
     def characteristics(self, T, n, u1max, nsamples=50,
-                        with_tmech=True, with_torque_corr=False):
+                        with_tmech=True, with_torque_corr=False, **kwargs):
         """calculate torque speed characteristics.
         return dict with list values of
         n, T, u1, i1, beta, cosphi, pmech, n_type

femagtools/machine/utils.py

@@ -303,11 +303,12 @@ def dqpar_interpol(xfit, dqpars, ipkey='temperature'):
         else:
             fpip[k] = ip.interp1d(
                 x, m, fill_value='extrapolate')(xfit).T
-    try:
-        for k in ('styoke_hyst', 'stteeth_hyst',
-                  'styoke_eddy', 'stteeth_eddy',
-                  'rotor_hyst', 'rotor_eddy',
-                  'magnet'):
+
+    for k in ('styoke_hyst', 'stteeth_hyst',
+              'styoke_eddy', 'stteeth_eddy',
+              'rotor_hyst', 'rotor_eddy',
+              'magnet'):
+        try:
             m = np.array([f['losses'][k] for f in sorted_dqpars]).T
             if len(x) > 2:
                 fpip['losses'][k] = np.array(
@@ -316,12 +317,13 @@ def dqpar_interpol(xfit, dqpars, ipkey='temperature'):
             else:
                 fpip['losses'][k] = ip.interp1d(
                     x, m, fill_value='extrapolate')(xfit).T
-            fpip['losses']['speed'] = dqpars[0]['losses']['speed']
-            for f in ('hf', 'ef'):
-                if f in dqpars[0]['losses']:
-                    fpip['losses'][f] = dqpars[0]['losses'][f]
-    except KeyError:
-        pass
+        except KeyError:
+            pass
+
+    fpip['losses']['speed'] = dqpars[0]['losses']['speed']
+    for f in ('hf', 'ef'):
+        if f in dqpars[0]['losses']:
+            fpip['losses'][f] = dqpars[0]['losses'][f]
     return x, fpip
 
 
@@ -351,52 +353,70 @@ def dqparident(workdir, engine, temp, machine,
     import pathlib
 
     wdgk = 'windings' if 'windings' in machine else 'winding'
-    da1 = machine['bore_diam']
-    Q1 = machine['stator']['num_slots']
+    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:
+        if kwargs.get('speed', 0) == 0:
+            raise ValueError('rated speed missing')
+        defspeed = kwargs['speed']
+
     lfe = machine['lfe']
     g = machine[wdgk].get('num_par_wdgs', 1)
-    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:
-        dy1 = machine['outer_diam']
-        hs = machine['stator'][slotmodel].get(
-            'slot_height', 0.6*(dy1-da1)/2)
-
     N = machine[wdgk]['num_wires']
-    Jmax = 20e6  # max current density in A/m2
-    f = machine[wdgk].get('fillfac', 0.42)
-    Acu = f*0.5*np.pi*(da1+hs)*hs
-    i1_max = round(Acu/Q1/N*Jmax/10)*10
+    if 'cufilfact' in machine[wdgk]:
+        fcu = machine[wdgk]['cufilfact']
+    elif 'fillfac' in machine[wdgk]:
+        fcu = machine[wdgk]['fillfac']
+    else:
+        fcu = 0.42
+
+    try: # calc basic dimensions if not fsl or dxf model
+        Q1 = machine['stator']['num_slots']
+        da1 = machine['bore_diam']
+        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:
+            dy1 = machine['outer_diam']
+            hs = machine['stator'][slotmodel].get(
+                'slot_height', 0.6*(dy1-da1)/2)
 
-    period_frac = kwargs.get('period_frac', 6)
-    if machine.get('external_rotor', False):
-        period_frac = 1  # TODO: missing femag support
+        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
+    except KeyError:
+        if kwargs.get('i1_max', 0) == 0:
+            raise ValueError('i1_max missing')
+        i1_max = kwargs['i1_max']
 
     # winding resistance
-    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']
-
-    wdg = windings.Winding(wpar)
-
-    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']
-    else:  # wire diameter from slot area
-        aw = 0.75 * machine[wdgk].get('cufilfact', 0.45)*\
-            np.pi*da1*hs/Q1/wpar['l']/N
-    r1 = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
+    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']
+        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)
+    except (NameError, KeyError):
+        r1 = 0  # cannot calc winding resistance
 
     n = len(temp)
     parvardef = {
@@ -415,6 +435,10 @@ def dqparident(workdir, engine, temp, machine,
     leakfile = pathlib.Path(workdir) / 'end_wind_leak.dat'
     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
+
     simulation = dict(
         calculationMode='ld_lq_fast',
         i1_max=kwargs.get('i1_max', i1_max),
@@ -426,12 +450,15 @@ def dqparident(workdir, engine, temp, machine,
         num_par_wdgs=machine[wdgk].get('num_par_wdgs', 1),
         num_cur_steps=kwargs.get('num_cur_steps', 5),
         num_beta_steps=kwargs.get('num_beta_steps', 7),
-        speed=kwargs.get('speed', 160/machine['poles']),
+        speed=kwargs.get('speed', defspeed),
         period_frac=period_frac)
 
     # TODO: cleanup()  # remove previously created files in workdir
     # start calculation
     results = parvar(parvardef, machine, simulation, engine)
+    if 'poles' not in machine:
+        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)
@@ -457,14 +484,25 @@ def dqparident(workdir, engine, temp, machine,
                            np.array(results['f'][i]['ldq'][k]))).tolist()
              for k in ('psid', 'psiq', 'torque', 'ld', 'lq', 'psim')})
         ldq.append(d)
-    losskeys = ('styoke_hyst', 'stteeth_hyst', 'styoke_eddy',
-                'stteeth_eddy', 'rotor_hyst', 'rotor_eddy',
-                'magnet')
+    # collect existing losses only
+    losskeymap = {'magnet': 'magnet'}
+    losskeys = [k for k in results['f'][0]['ldq']['losses']
+                if len(k.split('_')) > 1] + ['magnet']
+    for k in losskeys:
+        if k.find('_') > -1:
+            pref, post = k.split('_')
+            if pref.lower() == 'stza':
+                losskeymap[k] = 'stteeth_'+post
+            elif pref.lower() == 'stjo':
+                losskeymap[k] = 'styoke_'+post
+            else:
+                losskeymap[k] = k
     for i in range(0, len(results['f']), 2):
         j = i//2
         ldq[j]['temperature'] = results['x'][0][i]
-        ldq[j]['losses'] = {k: np.vstack((np.array(results['f'][i+1]['ldq']['losses'][k])[:-1, :],
-                                          np.array(results['f'][i]['ldq']['losses'][k]))).tolist()
+        ldq[j]['losses'] = {losskeymap[k]: np.vstack(
+            (np.array(results['f'][i+1]['ldq']['losses'][k])[:-1, :],
+             np.array(results['f'][i]['ldq']['losses'][k]))).tolist()
                             for k in losskeys}
         ldq[j]['losses']['speed'] = results['f'][i]['ldq']['losses']['speed']
         for k in ('hf', 'ef'):
@@ -473,10 +511,26 @@ def dqparident(workdir, engine, temp, machine,
     dqpars = {
         'm': machine[wdgk]['num_phases'],
         'p': machine['poles']//2,
-        'r1': machine[wdgk].get('resistance', r1),
         'ls1': ls1,
         "rotor_mass": rotor_mass, "kfric_b": 1,
         'ldq': ldq}
+    if 'resistance' in machine[wdgk]:
+        dqpars['r1'] = machine[wdgk]['resistance']
+    else:
+        if r1:
+            dqpars['r1'] = r1
+        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)
+            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
+            hs = asl/(np.pi*da1/3)
+            dqpars['r1'] = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
 
     if 'current_angles' in results['f'][0]:
         dqpars['current_angles'] = results['f'][0]['current_angles']

femagtools/mcv.py

@@ -50,6 +50,7 @@ transl = dict(
     rho='mc1_fe_spez_weigth',
     ch='mc1_ch_factor',
     cw='mc1_cw_factor',
+    ce='mc1_ce_factor',
     ch_freq='mc1_ch_freq_factor',
     cw_freq='mc1_cw_freq_factor',
     fillfac='mc1_fillfac',
@@ -58,6 +59,7 @@ transl = dict(
     bsat='mc1_bsat',
     Bo='mc1_base_induction',
     b_coeff='mc1_induction_factor',
+    b_beta_coeff='mc1_induction_beta_factor',
     fo='mc1_base_frequency',
     curve=[dict(
         hi='mc1_hi',
@@ -227,9 +229,12 @@ class Mcv(object):
         self.MC1_BASE_INDUCTION = 1.5
         self.MC1_CH_FACTOR = 0.0
         self.MC1_CW_FACTOR = 0.0
+        self.MC1_CE_FACTOR = 0.0
         self.MC1_CH_FREQ_FACTOR = 0.0
         self.MC1_CW_FREQ_FACTOR = 0.0
         self.MC1_INDUCTION_FACTOR = 0.0
+        self.MC1_INDUCTION_BETA_FACTOR = 0.0
+
         self.MC1_FE_SPEZ_WEIGTH = 7.65
         self.MC1_FE_SAT_MAGNETIZATION = 2.15
 
@@ -237,9 +242,11 @@ class Mcv(object):
         self.mc1_base_induction = self.MC1_BASE_INDUCTION
         self.mc1_ch_factor = self.MC1_CH_FACTOR
         self.mc1_cw_factor = self.MC1_CW_FACTOR
+        self.mc1_ce_factor = self.MC1_CE_FACTOR
         self.mc1_ch_freq_factor = self.MC1_CH_FREQ_FACTOR
         self.mc1_cw_freq_factor = self.MC1_CW_FREQ_FACTOR
         self.mc1_induction_factor = self.MC1_INDUCTION_FACTOR
+        self.mc1_induction_beta_factor = self.MC1_INDUCTION_BETA_FACTOR
         self.mc1_fe_spez_weigth = self.MC1_FE_SPEZ_WEIGTH
         self.mc1_fe_sat_magnetization = self.MC1_FE_SAT_MAGNETIZATION
 
@@ -519,6 +526,13 @@ class Writer(Mcv):
                          float(self.mc1_fe_sat_magnetization)])
 
         if not hasattr(self, 'losses') or not self.losses:
+            # new variables: ce factor for bertotti losses
+            # b_beta_coeff for modified steinmetz
+            try: 
+                self.writeBlock([float(self.mc1_ce_factor), 
+                                 float(self.mc1_induction_beta_factor)])
+            except: 
+                pass
             return
 
         try:
@@ -585,7 +599,7 @@ class Writer(Mcv):
             logger.info('Losses n freq %d n ind %d', nfreq, nind)
         except Exception as e:
             logger.error("Exception %s", e, exc_info=True)
-
+        
     def writeMcv(self, filename, fillfac=None, recsin=''):
         # windows needs this strip to remove '\r'
         filename = filename.strip()
@@ -857,6 +871,16 @@ class Reader(Mcv):
                 if not self.losses['f'] or not self.losses['pfe']:
                     self.losses = {}
 
+        self.ce = 0
+        self.b_beta_coeff = 0
+        try: 
+            if not self.losses['f'][0]:
+                self.fp.seek(-16, 1)
+            res = self.readBlock([float]*2)
+            self.ce, self.b_beta_coeff = res[0], res[1]
+        except:
+            pass
+
     def get_results(self):
         result = {
             'name': self.name,
@@ -873,6 +897,8 @@ class Reader(Mcv):
             'ch': self.ch,
             'ch_freq': self.ch_freq,
             'cw': self.cw,
+            'ce': self.ce,
+            'b_beta_coeff': self.b_beta_coeff,
             'cw_freq': self.cw_freq,
             'b_coeff': self.b_coeff,
             'rho': self.rho,

femagtools/model.py

@@ -379,6 +379,7 @@ class MachineModel(Model):
     def rotortype(self):
         """return type of rotor slot"""
         for k in self.rotor:
+            # anything that is a dict must represent the type
             if isinstance(self.rotor[k], dict):
                 return k
         raise AttributeError("Missing rotor model in {}".format(self.magnet))
@@ -386,8 +387,9 @@ class MachineModel(Model):
     def magnettype(self):
         """return type of magnet slot"""
         for k in self.magnet:
-            if k != 'material' and isinstance(self.magnet[k], dict):
-                return k
+            if k not in {'material', 'temp_prop'}:
+                if isinstance(self.magnet[k], dict):
+                    return k
         raise AttributeError("Missing magnet model in {}".format(self.magnet))
 
     def is_complete(self):

femagtools/nc.py

@@ -262,6 +262,7 @@ class Reader(object):
         ce_ind_exp = 1.5
         ke = 0.0
         khml = 0.65
+        cw_ind_beta_exp = 0
 
         lctype = ['magn_curve']*lmc + ['Outside', 'Inside']
         for i in range(lmc+2):
@@ -280,6 +281,11 @@ class Reader(object):
                 cw = float(mcgrp.variables['cw'][i].data)
                 cw_freq_exp = float(mcgrp.variables['cw_exp'][i].data)
                 cw_ind_exp = float(mcgrp.variables['ind_exp'][i].data)
+                try: 
+                    ce = float(mcgrp.variables['ce'][i].data)
+                    cw_ind_beta_exp = float(mcgrp.variables['ind_beta_exp'][i].data)
+                except: 
+                    pass
                 spec_weight = float(mcgrp.variables['spec_weight'][i].data)
                 fillfactor = float(mcgrp.variables['fillfac'][i].data)
                 shapefactor = 1.0
@@ -327,6 +333,7 @@ class Reader(object):
                 "cw_freq_exp": cw_freq_exp,
                 "cw_ind_exp": cw_ind_exp,
                 "ce": ce,
+                "cw_ind_beta_exp": cw_ind_beta_exp,
                 "ce_freq_exp": ce_freq_exp,
                 "ce_ind_exp": ce_ind_exp,
                 "ke": ke,

femagtools/opt.py

@@ -82,7 +82,7 @@ class Optimizer(object):
                 task.add_file(self.fea['pocfilename'],
                               self.fea['poc'].content())
             if 'stateofproblem' in self.fea:
-                task.set_stateofproblem(fea['stateofproblem'])
+                task.set_stateofproblem(self.fea['stateofproblem'])
         tstart = time.time()
         ntasks = engine.submit()
         status = engine.join()

femagtools/parstudy.py

@@ -181,10 +181,13 @@ class ParameterStudy(object):
         simulation['lfe'] = model.lfe
         simulation['move_action'] = model.move_action
         simulation['phi_start'] = 0.0
-        simulation['range_phi'] = 720/model.get('poles')
+        try:
+            simulation['range_phi'] = 720/model.get('poles')
+        except AttributeError: #  if dxf or pure fsl model
+            simulation['range_phi'] = 0.0
         simulation.update(model.winding)
         if 'pocfilename' not in simulation:
-            simulation['pocfilename'] = f"{model.name}_{model.poles}p.poc"
+            simulation['pocfilename'] = f"{model.name}.poc"
         fea = femagtools.model.FeaModel(simulation)
 
         prob = femagtools.moproblem.FemagMoProblem(decision_vars,