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

femagtools/femag.py

@@ -26,6 +26,7 @@ import femagtools.airgap as ag
 import femagtools.fsl
 import femagtools.config
 import femagtools.ecloss
+import femagtools.forcedens
 
 from femagtools import ntib
 
@@ -248,6 +249,9 @@ class BaseFemag(object):
     def get_bch_file(self, modelname, offset=0):
         return self.get_result_file(modelname, 'B(AT)?CH', offset)
 
+    def get_plt_file(self, modelname, offset=0):
+        return self.get_result_file(modelname, 'PLT0', offset)
+
     def get_asm_file(self, modelname, offset=0):
         return self.get_result_file(modelname, 'ASM', offset)
 
@@ -317,6 +321,17 @@ class BaseFemag(object):
                 result.read(f)
         return result
 
+    def read_forcedens(self, modelname=None, offset=0):
+        "read most recent PLT0 file and return result"
+        if not modelname:
+            modelname = self._get_modelname_from_log()
+
+        pltfile = self.get_plt_file(modelname, offset)
+        if pltfile:
+            logger.info("Read PLT0 {}".format(pltfile))
+            return femagtools.forcedens.read(pltfile)
+        return None
+
     def read_isa(self, modelname=None):
         "read most recent I7/ISA7 file and return result"
         if not modelname:
@@ -555,6 +570,13 @@ class Femag(BaseFemag):
                                               simulation)))
         if simulation:
             stateofproblem = simulation.get('stateofproblem', 'mag_static')
+            if 'eccentricity' in simulation:
+                #assert (self.model.stator['num_slots']
+                #        == self.model.stator['num_slots_gen'])
+                for k in ('bore_diam', 'airgap'):
+                    if k not in simulation['eccentricity']:
+                        simulation['eccentricity'][k] = self.model.get(k)
+
             if 'poc' in simulation:
                 with open(os.path.join(self.workdir,
                                        simulation['pocfilename']), 'w') as f:
@@ -579,8 +601,9 @@ class Femag(BaseFemag):
         self.run(fslfile, options, fsl_args, stateofproblem=stateofproblem)
         if simulation:
             return self.readResult(simulation)
-        return dict(status='ok', message=self.modelname)
 
+        return {'status': 'ok', 'message': self.modelname,
+                'model': self.model.props()}
 
 class FemagTask(threading.Thread):
     def __init__(self, port, args, workdir, logdir):
@@ -1096,7 +1119,9 @@ class ZmqFemag(BaseFemag):
             raise FemagError(r['message'])
 
         if not simulation:
-            return [r, dict(name=machine['name'])]
+            model = self.model.props()
+            model['name'] = machine['name']
+            return [r, model]
 
         result_file = r['result_file'][0]
         if simulation['calculationMode'] == "pm_sym_loss":

femagtools/forcedens.py

@@ -51,6 +51,22 @@ def _readSections(f):
     yield section
 
 
+def _complete(positions):
+    """return FN and FT Matrix completed to full model"""
+    ntiles = int(360/positions[0]['X'][-1])
+    try:
+        FN = np.tile(
+            np.array([p['FN'][:-1] for p in positions[:-1]]), (1, ntiles))
+        FT = np.tile(
+            np.array([p['FT'][:-1] for p in positions[:-1]]), (1, ntiles))
+    except AttributeError:
+        return [[], []]
+
+    rotangle = positions[-1]['position'] - positions[0]['position']
+    mtiles = int(round(360/rotangle))
+    return np.tile(FN, (mtiles, 1)).T, np.tile(FT, (mtiles, 1)).T
+
+
 class ForceDensity(object):
 
     def __init__(self):
@@ -109,7 +125,9 @@ class ForceDensity(object):
             rec = l.split()[1:]
             if len(rec) == len(labels):
                 m.append([float(x) for x in rec])
-        d.update({k: v for k, v in zip(labels, list(zip(*m)))})
+        logging.debug("POSITION %s len %d: %s", d['position'],
+                      len(m), ','.join(labels))
+        d.update(dict(zip(labels, list(zip(*m)))))
 
         self.positions.append(d)
 
@@ -129,36 +147,33 @@ class ForceDensity(object):
                     self.__read_date_and_title(s)
                 elif s[0].startswith('POSITION'):
                     self.__read_position(s)
-
-    def _prepare(self):
-        """return FN and FT Matrix"""
-        ntiles = int(360/self.positions[0]['X'][-1])
-        try:
-            FN = np.tile(
-                np.array([p['FN'][:-1] for p in self.positions[:-1]]).T,
-                (ntiles, 1))
-            FT = np.tile(
-                np.array([p['FT'][:-1] for p in self.positions[:-1]]).T,
-                (ntiles, 1))
-        except AttributeError:
-            return []
-        return [FN, FT]
+            pos = [p['position'] for p in self.positions]
+            labels = self.positions[0].keys()
+            fn = [p['FN'] for p in self.positions]
+            fnmax = max([max(x) for x in fn])
+            fnmin = min([min(x) for x in fn])
+            flen = set([len(x) for x in fn])
+            if len(flen) > 1:
+                logging.warning("inhomogenous samples: %s", flen)
+            logging.info("%s shape %s: pos %s, FN %s %s",
+                         filename, (len(pos), min(list(flen))),
+                         (min(pos), max(pos)),
+                         (fnmin, fnmax),
+                         ','.join(labels))
+            self.FN, self.FT = _complete(self.positions)
 
     def fft(self):
         """return 2D FFT of the Force Density"""
-        fdens = self._prepare()
-        FN, FT= fdens[0], fdens[1]
-        N = FN.size
-        dim = FN.shape[0]//2
+        N = self.FN.size
+        dim = self.FN.shape[0]//2
         # Dimension [Position °] X [Time Steps s]
-        FN_MAG = np.fft.fft2(FN)[0:dim, :]/N
-        FT_MAG = np.fft.fft2(FT)[0:dim, :]/N
+        FN_MAG = np.fft.fft2(self.FN)[0:dim, :]/N
+        FT_MAG = np.fft.fft2(self.FT)[0:dim, :]/N
 
-        return dict(fn_harm=dict(amplitude=np.abs(FN_MAG),
-                                phase=np.angle(FN_MAG)),
-                    ft_harm=dict(amplitude=np.abs(FT_MAG),
-                                phase=np.angle(FT_MAG))
-                    )
+        return {'fn_harm': {'amplitude': np.abs(FN_MAG),
+                            'phase': np.angle(FN_MAG)},
+                'ft_harm': {'amplitude': np.abs(FT_MAG),
+                            'phase': np.angle(FT_MAG)}}
 
     def items(self):
         return [(k, getattr(self, k)) for k in ('version',
@@ -210,9 +225,13 @@ def readall(workdir='.'):
 
 
 if __name__ == "__main__":
-    import matplotlib.pyplot as pl
+    import matplotlib.pyplot as plt
     import femagtools.plot
     import sys
+
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s %(message)s')
+
     if len(sys.argv) == 2:
         filename = sys.argv[1]
     else:
@@ -221,16 +240,22 @@ if __name__ == "__main__":
     fdens = read(filename)
 
     # Show the results
-    print(fdens.version)
-
-    title = '{}, Rotor position {}'.format(
-        fdens.title, fdens.positions[0]['position'])
-    pos = fdens.positions[0]['X']
-    FT_FN = (fdens.positions[0]['FT'],
-             fdens.positions[0]['FN'])
-    femagtools.plot.forcedens(title, pos, FT_FN)
-    pl.show()
-
-    title = 'Force Density Harmonics'
-    femagtools.plot.forcedens_fft(title, fdens)
-    pl.show()
+    #print(fdens.version)
+
+    #title = '{}, Rotor position {}'.format(
+    #    fdens.title, fdens.positions[0]['position'])
+    #pos = fdens.positions[0]['X']
+    #FT_FN = (fdens.positions[0]['FT'],
+    #         fdens.positions[0]['FN'])
+    #femagtools.plot.forcedens(title, pos, FT_FN)
+    #pl.show()
+
+    #femagtools.plot.forcedens_surface(fdens)
+    #pl.show()
+
+    title = 'Radial Force Density'
+    fig, ax = plt.subplots()
+    fig.suptitle(title)
+    femagtools.plot.forcedens_contour(fdens, ax=ax)
+    plt.tight_layout()
+    plt.show()

femagtools/fsl.py

@@ -7,7 +7,7 @@ import mako.lookup
 import os
 import re
 import sys
-import math
+import numpy as np
 import femagtools.windings
 from femagtools.poc import Poc
 from . import __version__
@@ -73,7 +73,7 @@ class Builder:
 
             g = femagtools.gmsh.Gmsh(model.stator['mshfile']['name'])
             phi = g.get_section_angles()
-            model.stator['num_slots'] = round(math.pi/(phi[1]-phi[0]))
+            model.stator['num_slots'] = round(np.pi/(phi[1]-phi[0]))
             r = g.get_section_radius()
             model.set_value('outer_diam', 2*r[1])
             model.set_value('bore_diam', 2*r[0])
@@ -92,7 +92,7 @@ class Builder:
             self.fsl_stator = True
             return
 
-        if templ == 'statorFsl' or templ == 'dxf':
+        if templ in ('statorFsl', 'dxf'):
             self.fsl_stator = True
 
         if templ != 'dxffile':
@@ -111,10 +111,13 @@ class Builder:
         conv = convert(model.stator['dxffile']['name'], **params)
 
         model.stator['num_slots'] = conv.get('tot_num_slot')
+        model.set_value('poles', conv.get('num_poles'))
         self.set_diameter_parameter(model, conv)
         if model.get('dy1'):
             model.set_value('outer_diam', model.get('dy1'))
             model.set_value('bore_diam', model.get('da1'))
+        if 'agndst' in conv:
+            model.set_value('agndst', model.get('agndst'))
 
         model.stator['dxf'] = dict(fsl=conv['fsl'])
         self.fsl_stator = True
@@ -126,6 +129,8 @@ class Builder:
                 model.set_value(v, conv[v])
             except KeyError:
                 pass
+        if conv.keys() >= {'da1', 'da2'}:
+            model.set_value('airgap', abs(model.da1 - model.da2)/2)
 
     def prepare_diameter(self, model):
         dy1 = model.get('dy1', 0.0)
@@ -144,10 +149,11 @@ class Builder:
     def render_stator(self, model):
         templ = model.statortype()
         if templ == 'dxf':
-            return [
-                'agndst = {}'.format(model.agndst*1e3),
-                'ndt(agndst)'
-            ] + model.stator['dxf']['fsl']
+            agndst = []
+            if model.get('agndst', 0) > 0:
+                agndst = ['agndst = {}'.format(model.agndst*1e3)]
+            return (agndst + ['ndt(agndst)']
+                    + model.stator['dxf']['fsl'])
         if templ == 'statorFsl':
             #  obsolete
             if 'parameter' in model.stator['statorFsl']:
@@ -190,8 +196,8 @@ class Builder:
         if fslcode:
             if self.fsl_stator:
                 return (['agndst = {}'.format(model.agndst*1e3),
-                         'alfa = 2*math.pi*m.num_sl_gen/m.tot_num_slot',
-                         'num_agnodes = math.floor(m.fc_radius*alfa/agndst + 0.5)'] +
+                         'alfa = 2*np.pi*m.num_sl_gen/m.tot_num_slot',
+                         'num_agnodes = np.floor(m.fc_radius*alfa/agndst + 0.5)'] +
                         fslcode)
             if hasattr(model, 'num_agnodes'):
                 return fslcode
@@ -276,7 +282,7 @@ class Builder:
             g = femagtools.gmsh.Gmsh(model.magnet['mshfile']['name'])
             r = g.get_section_radius()
             phi = g.get_section_angles()
-            p = round(math.pi/(phi[1]-phi[0]))
+            p = round(np.pi/(phi[1]-phi[0]))
             model.set_value('poles', p)
             model.set_value('inner_diam', 2*r[0])
             ag = (model.get('bore_diam') - 2*r[1])/2
@@ -298,7 +304,7 @@ class Builder:
             return
 
         if templ == 'dxf':
-            # reuse dxfsl model 
+            # reuse dxfsl model
             self.fsl_magnet = True
         if templ != 'dxffile':
             return
@@ -330,7 +336,7 @@ class Builder:
         if fslcode:
             return fslcode
 
-        logger.error('File {}.fsl not found'.format(templ))
+        logger.error('File %s.fsl not found', templ)
         return []
 
     def create_connect_models(self, model):
@@ -346,7 +352,7 @@ class Builder:
                     '-- thermal properties in airgap',
                     'ag_cond = 0.063',
                     'thcap = 1007',
-                    'beta = math.pi*m.npols_gen/m.num_poles + m.zeroangl/180*math.pi',
+                    'beta = np.pi*m.npols_gen/m.num_poles + m.zeroangl/180*np.pi',
                     'xai, yai = pr2c((da1+da2)/4, beta)',
                     'def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
                     'xai, yai = pr2c((da1+da2)/4-ag/4, beta)',
@@ -434,13 +440,11 @@ class Builder:
             logger.info("Leakage type %s", k)
             if 'wiredia' not in model.winding[k[0]]:
                 if 'wire_gauge' in model.winding:
-                    import numpy as np
                     d = 2*np.sqrt(model.winding['wire_gauge']/np.pi)
                     model.winding[k[0]]['wiredia'] = d
                 elif 'dia_wire' in model.winding:
                     model.winding[k[0]]['wiredia'] = model.winding['dia_wire']
                 elif 'wire_width' in model.winding:
-                    import numpy as np
                     w = model.winding['wire_width']
                     h = model.winding['wire_height']
                     d = 2*np.sqrt(h*w/np.pi)
@@ -462,10 +466,10 @@ class Builder:
             logger.error('Name of dxf-file expected')
             return []
 
-        if dxfname.split('.')[-1] not in ('dxf'):
+        if dxfname.split('.')[-1] not in ('dxf', 'svg'):  # add svg support
             dxfname += '.dxf'
         if not os.path.isfile(dxfname):
-            logger.error('File {} not found'.format(dxfname))
+            logger.error('File "%s" not found', dxfname)
             raise ValueError(f'File {dxfname} not found')
 
         params = {}
@@ -474,7 +478,7 @@ class Builder:
         params['write_fsl'] = True
         params['airgap'] = model.dxffile.get('airgap', 0.0)
         params['nodedist'] = model.dxffile.get('nodedist', 1)
-
+        params['full_model'] = model.dxffile.get('full_model', False)
         conv = convert(dxfname, **params)
 
         model.set_value('poles', conv.get('num_poles'))
@@ -482,16 +486,20 @@ class Builder:
         model.set_value('bore_diam', conv.get('da1') * 1e-3)
         model.set_value('inner_diam', conv.get('dy2') * 1e-3)
         model.set_value('airgap', (conv.get('da1') - conv.get('da2'))/2/1e3)
-        model.set_value('agndst', conv.get('agndst')*1e-3)
+        model.set_value('external_rotor', conv.get('external_rotor'))
 
         if not hasattr(model, 'stator'):
             setattr(model, 'stator', {})
         model.stator['num_slots'] = conv.get('tot_num_slot')
-        if model.stator.get('num_slots_gen', 0):
-            if model.stator['num_slots'] % model.stator['num_slots_gen'] > 0:
-                model.stator['num_slots_gen'] = conv.get('num_sl_gen')
+        if params['full_model']:
+            model.stator['num_slots_gen'] = model.stator['num_slots']
         else:
-            model.stator['num_slots_gen'] = conv.get('num_sl_gen')
+            if model.stator.get('num_slots_gen', 0):
+                if model.stator['num_slots'] % model.stator['num_slots_gen'] > 0:
+                    model.stator['num_slots_gen'] = conv.get('num_sl_gen')
+            else:
+                model.stator['num_slots_gen'] = conv.get('num_sl_gen')
+
         if 'fsl_stator' in conv:
             self.fsl_stator = True
             model.stator['dxf'] = dict(fsl=conv['fsl_stator'])
@@ -523,12 +531,27 @@ class Builder:
             logger.info("create new model '%s'", model.name)
             if model.is_dxffile():
                 self.prepare_model_with_dxf(model)
+                if model.get('num_agnodes', 0) == 0:
+                    from femagtools.dxfsl.fslrenderer import agndst
+                    ag = model.get('airgap')
+                    model.set_value(
+                        'agndst',
+                        agndst(model.get('bore_diam'),
+                               model.get('bore_diam') - 2*ag,
+                               model.stator.get('num_slots'),
+                               model.get('poles'),
+                               model.stator.get('nodedist') or 1.0))
+
+                logger.info(" num poles %d num slots %d outer diameter %.4f m",
+                            model.poles, model.stator['num_slots'],
+                            model.outer_diam)
+
             else:
                 self.prepare_stator(model)
                 if hasattr(model, 'magnet'):
                     self.prepare_magnet(model)
                 self.prepare_diameter(model)
-                if self.fsl_stator:
+                if self.fsl_stator and model.get('num_agnodes', 0) == 0:
                     from femagtools.dxfsl.fslrenderer import agndst
                     ag = model.get('airgap')
                     model.set_value(
@@ -638,6 +661,11 @@ class Builder:
         except:
             return []
 
+    def create_displ_stator_rotor(self, exc):
+        if exc.keys() >= {'type', 'bore_diam', 'airgap', 'ecc'}:
+            return self.__render(exc, 'displ_stator_rotor')
+        return []
+
     def create_analysis(self, sim):
         pfefunc = sim.get('loss_funct', '')
         custom_fefunc = ['']
@@ -650,9 +678,23 @@ class Builder:
 
         airgap_induc = (self.create_airgap_induc()
                         if sim.get('airgap_induc', 0) else [])
+        displ_stator_rotor = self.create_displ_stator_rotor(
+            sim.get('eccentricity', {}))
+        revert_displ = []
+        if displ_stator_rotor:
+            sim['eval_force'] = 1
+            sim['period_frac'] = 1
+            if sim['eccentricity']['type'] == 'static':
+                sim['explicit_mode'] = 1
+                sim['range_phi'] = 180
+            sim['eccentricity']['ecc'] = -sim['eccentricity']['ecc']
+            revert_displ = self.create_displ_stator_rotor(
+                sim['eccentricity'])
+
         felosses = custom_fefunc + self.create_fe_losses(sim)
-        fslcalc = (self.__render(sim, sim.get('calculationMode')) +
-                   airgap_induc)
+        fslcalc = (displ_stator_rotor
+                   + self.__render(sim, sim.get('calculationMode'))
+                   + airgap_induc + revert_displ)
         '''
         if pfefunc:
             sim['loss_funct'] = pfefunc
@@ -687,8 +729,8 @@ class Builder:
     def create(self, model, sim, magnets=None, condMat=[]):
         "create model and analysis function"
         try:
-            sim['lfe'] = model.get('lfe')
             num_poles = model.get('poles')
+            sim['lfe'] = model.get('lfe')
         except AttributeError:
             pass
         try:
@@ -713,10 +755,11 @@ class Builder:
             try:
                 poc = Poc(2*360/num_poles)
                 sim['poc'] = poc
-                sim['pocfilename'] = poc.filename()
+                sim['pocfilename'] = poc.filename(model.get('name'))
             except UnboundLocalError:
                 logger.warning("unknown number of poles")
                 pass
+        logger.info("Poc file %s", sim.get('pocfilename', '<undefined>'))
 
         if 'phi_start' not in sim:
             sim['phi_start'] = 0.0

femagtools/losscoeffs.py

@@ -83,6 +83,52 @@ def fitjordan(f, B, losses, Bo, fo):
     return fitp
 
 
+def fit_bertotti(f, B, losses):
+    """fit coeffs of
+    losses(f,B)=(ch*f + ch*f**2)*B**2 + ce*f**1.5*B**1.5
+    returns (ch, cw, ce)
+
+    Args:
+        f: list of n strictly increasing frequency values
+        B: list of n or list of list of induction values (nxm)
+        losses: list of list of fe loss values (nxm)
+    """
+    i0 = 0
+    if np.isclose(f[i0], 0):
+        i0 = 1
+    v = []
+    # collect losses and flux density along the frequency
+    for k in range(len(losses[i0])):
+        y = []
+        bb = []
+        if isinstance(B[0], tuple) or isinstance(B[0], list):
+            for fx, bx, p in zip(f[i0:], B[i0:], losses[i0:]):
+                if k < len(p):
+                    y.append(p[k]/fx)
+                    bb.append(bx[k])
+        else:
+            for fx, p in zip(f[i0:], losses[i0:]):
+                if k < len(p):
+                    y.append(p[k]/fx)
+                    bb.append(B[k])
+        j = len(y)
+        if j > 2:
+            v.append(np.array((f[i0:j+i0], bb, y)).T.tolist())
+
+    def wbert(f, b, ch, cw, cx):
+        return (ch + cw*f)*b**2 + cx*f**0.5*b**1.5
+
+    z = np.array([b for a in v for b in a]).T
+    fbx = z[0:2]
+    y = z[2]
+    fitp, _ = so.curve_fit(
+        lambda x, ch, cw, ce: wbert(
+            x[0], x[1], ch, cw, ce),
+        fbx, y,
+        bounds=[(0, 0, 0),
+                (np.inf, np.inf, np.inf)])
+    return fitp
+
 def fit_bertotti0(f, B, losses, generate=False):
     """fit coeffs of
     losses(f,B)=(ch*f + ch*f**2)*B**2 + ce*f**1.5*B**1.5

femagtools/machine/effloss.py

@@ -309,13 +309,20 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
             r['plcu1'].append(m.m*np.abs(i1)**2*m.rstat(w1))
             r['plcu2'].append(m.m*np.abs(i2)**2*m.rrot(w1-m.p*wm))
 
-    if isinstance(m, (PmRelMachine, SynchronousMachine)):
+    if isinstance(m, PmRelMachine):
         plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
         plfe2 = m.kpfe*m.iqd_plfe2(iqd[0], iqd[1], f1)
         plmag = m.kpmag*m.iqd_plmag(iqd[0], iqd[1], f1)
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], 2*np.pi*f1)
         plcu2 = m.iqd_plcu2(*iqd)
         tfric = m.tfric
+    elif isinstance(m, SynchronousMachine):
+        plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
+        plfe2 = m.kpfe*m.iqd_plfe2(*iqd, f1)
+        plmag = np.zeros_like(plfe2)
+        plcu1 = m.iqd_plcu1(iqd[0], iqd[1], 2*np.pi*f1)
+        plcu2 = m.iqd_plcu2(*iqd)
+        tfric = m.tfric
     else:
         plfe1 = np.array(r['plfe1'])
         plfe2 = np.zeros(ntmesh.shape[1])

femagtools/machine/im.py

@@ -230,7 +230,7 @@ class InductionMachine(Component):
 
     def i1(self, w1, psi, wm):
         """stator current"""
-        imag = complex(self.imag(psi))
+        imag = self.imag(psi)+0j
         if abs(w1) > 0:
             imag += w1*psi/self.rfe(w1, psi)*1j
         return self.i2(w1, psi, wm) + imag
@@ -577,6 +577,8 @@ class InductionMachine(Component):
                 r['n'].append(wm/2/np.pi)
                 r['s'].append(float((w1 - self.p * wm) / w1))
                 r['sk'].append(self.sk(w1, np.abs(u1)/w1))
+                # add n_type to result dict
+                r['n_type'] = wmType/2/np.pi
                 #            except ValueError as ex:
                 #                break
         r['plfw'] = [self.pfric(n) for n in r['n']]

femagtools/machine/pm.py

@@ -268,9 +268,11 @@ class PmRelMachine(object):
         u -- the maximum voltage (RMS)
         iq, id -- the d-q currents"""
         w10 = np.sqrt(2)*u/la.norm(self.psi(iq, id))
-        return so.fsolve(
-            lambda w1: la.norm(self.uqd(w1, iq, id))-u*np.sqrt(2),
-            w10)[0]
+        with warnings.catch_warnings():
+            warnings.simplefilter("ignore")
+            return so.fsolve(
+                lambda w1: la.norm(self.uqd(w1, iq, id))-u*np.sqrt(2),
+                w10)[0]
 
     def w1_imax_umax(self, i1max, u1max):
         """return frequency w1 and torque at voltage u1max and current i1max
@@ -584,7 +586,7 @@ class PmRelMachine(object):
                                            i1max=i1max)
                 return iq, id, tq
             except ValueError as e:
-                logger.warning(e)
+                logger.debug(e)
 
         if with_tmech:
             tq = self.tmech_iqd(iq, id, w1/2/np.pi/self.p)
@@ -798,8 +800,8 @@ class PmRelMachine(object):
                         k, wx, wl, wu, 100*(wu-wl)/wl)
 
         self.check_extrapolation = True
-        w1max = min(w1max, self.w1_umax(
-            u1max, *iqd(-np.pi/2, abs(i1max))))
+        w1max = min(w1max, np.floor(self.w1_umax(
+            u1max, *iqd(-np.pi/2, abs(i1max)))))
         return [w/2/np.pi/self.p for w in (w1type, w1max)]  # ['MTPA']
 
 
@@ -907,6 +909,8 @@ class PmRelMachine(object):
         with_mtpa -- (optional) use mtpa if True (default) in const speed range, set id=0 if false
         with_tmech -- (optional) use friction and windage losses if True (default)
         with_torque_corr -- (optional) T is corrected if out of range
+        Optional arguments:
+        i1max: max. phase current (RMS)
         """
         r = dict(id=[], iq=[], uq=[], ud=[], u1=[], i1=[], T=[],
                  beta=[], gamma=[], phi=[], cosphi=[], pmech=[], n=[])
@@ -1396,11 +1400,8 @@ class PmRelMachinePsidq(PmRelMachine):
                                   'rotor_excess']
             self._set_losspar(pfe)
             self._losses = {k: ip.RectBivariateSpline(
-                iq, id, np.array(pfe[k])).ev for k in (
-                'styoke_hyst', 'stteeth_hyst',
-                'styoke_eddy', 'stteeth_eddy',
-                'rotor_hyst', 'rotor_eddy',
-                'magnet')}
+                iq, id, np.array(pfe[k])).ev for k in self.losskeys
+                if k in pfe}
         except KeyError as e:
             logger.warning("loss map missing: %s", e)
             pass