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

femagtools/dxfsl/shape.py

@@ -9,7 +9,6 @@
 """
 from __future__ import print_function
 import numpy as np
-import sys
 import logging
 from .functions import less_equal, greater_equal
 from .functions import distance, line_m, line_n
@@ -18,7 +17,7 @@ from .functions import alpha_line, alpha_angle, alpha_triangle
 from .functions import normalise_angle, min_angle, max_angle, get_angle_of_arc
 from .functions import lines_intersect_point, nodes_are_equal
 from .functions import is_angle_inside, intersect_point
-from .functions import middle_angle
+from .functions import middle_angle, middle_point_of_line
 
 logger = logging.getLogger('femagtools.geom')
 
@@ -50,7 +49,10 @@ class Shape(object):
         if hasattr(s, 'my_attrs'):
             self.my_attrs = []
             for a in s.my_attrs:
-               self.my_attrs.append(a)
+                self.my_attrs.append(a)
+
+    def classname(self):
+        return "Shape"
 
     def get_my_color(self):
         if hasattr(self, 'my_color'):
@@ -209,8 +211,8 @@ class Shape(object):
         d1 = distance(n, self.n1)
         d2 = distance(n, self.n2)
         if d1 == d2:
-            logger.info("distances of %s and %s are equal (%s / %s)",
-                        self.n1, self.n2, d1, d2)
+            logger.warning("distances of %s and %s are equal (%s / %s)",
+                           self.n1, self.n2, d1, d2)
             raise ValueError('both nodes are equal in element')
 
         if d1 < d2:
@@ -307,6 +309,9 @@ class Circle(Shape):
         self.n1 = None
         self.n2 = None
 
+    def classname(self):
+        return "Circle"
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -544,6 +549,19 @@ class Circle(Shape):
         assert(len(points) == 0)
         return []
 
+    def cut_into_halves(self):
+        """ return two arcs
+        """
+        a1 = Arc(Element(center=self.center,
+                         radius=self.radius,
+                         start_angle=0.0,
+                         end_angle=180.0))
+        a2 = Arc(Element(center=self.center,
+                         radius=self.radius,
+                         start_angle=180.0,
+                         end_angle=0.0))
+        return a1, a2
+
     def get_angle_of_arc(self):
         return np.pi*2.0
 
@@ -608,6 +626,9 @@ class Arc(Circle):
         else:
             self.rtheta = None
 
+    def classname(self):
+        return "Arc"
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -715,8 +736,9 @@ class Arc(Circle):
                 points.append(e.p2)
 
         elif e.is_point_inside(self.p2, rtol, atol):
-            if not points_are_close(self.p1, e.p1):
+            if not points_are_close(self.p1, e.p1, rtol=rtol, atol=atol):
                 logger.error("FATAL ERROR in overlapping_shape() of Arc")
+
                 raise ValueError('FATAL ERROR in overlapping_shape() of Arc')
             points.append(e.p1)
             points.append(self.p2)
@@ -808,6 +830,20 @@ class Arc(Circle):
         assert(len(points_inside) == 0)
         return []
 
+    def cut_into_halves(self):
+        """ return two arcs
+        """
+        midangle = middle_angle(self.startangle, self.endangle)
+        a1 = Arc(Element(center=self.center,
+                         radius=self.radius,
+                         start_angle=self.startangle*180/np.pi,
+                         end_angle=midangle*180/np.pi))
+        a2 = Arc(Element(center=self.center,
+                         radius=self.radius,
+                         start_angle=midangle*180/np.pi,
+                         end_angle=self.endangle*180/np.pi))
+        return a1, a2
+
     def concatenate_arc(self, n1, n2, el):
         if not points_are_close(self.center, el.center):
             return None
@@ -833,30 +869,30 @@ class Arc(Circle):
     def is_point_inside(self, p, rtol=1e-03, atol=1e-03, include_end=False):
         """ returns true if p is on arc
         """
-        logger.debug("is_point_inside: p=%s", p)
+        # logger.debug("is_point_inside: p=%s", p)
         d = distance(p, self.center)
         if not np.isclose(d, self.radius, rtol=rtol, atol=atol):
-            logger.debug(" <== RADIUS %s, DISTANCE %s",
-                         self.radius, d)
+            # logger.debug(" <== RADIUS %s, DISTANCE %s",
+            #              self.radius, d)
             return False
         if points_are_close(p, self.p1, rtol=rtol, atol=atol):
-            logger.debug(" <== CLOSE TO P1 %s: rtol=%s, atol=%s",
-                         self.p1, rtol, atol)
+            # logger.debug(" <== CLOSE TO P1 %s: rtol=%s, atol=%s",
+            #              self.p1, rtol, atol)
             return include_end
         elif points_are_close(p, self.p2, rtol=rtol, atol=atol):
-            logger.debug(" <== CLOSE TO P2 %s: rtol=%s, atol=%s",
-                         self.p2, rtol, atol)
+            # logger.debug(" <== CLOSE TO P2 %s: rtol=%s, atol=%s",
+            #              self.p2, rtol, atol)
             return include_end
         elif points_are_close(self.p1, self.p2, rtol=rtol, atol=atol):
-            logger.debug(" <== P1 AND P2 CLOSE TOGETHER")
+            # logger.debug(" <== P1 AND P2 CLOSE TOGETHER")
             return False
 
         alpha_p1 = alpha_line(self.center, self.p1)
         alpha_p2 = alpha_line(self.center, self.p2)
         alpha_p = alpha_line(self.center, p)
         alpha_inside = is_angle_inside(alpha_p1, alpha_p2, alpha_p)
-        logger.debug("is_point_inside: %s (%s, %s ,%s)",
-                     alpha_inside, alpha_p1, alpha_p2, alpha_p)
+        # logger.debug("is_point_inside: %s (%s, %s ,%s)",
+        #              alpha_inside, alpha_p1, alpha_p2, alpha_p)
         return alpha_inside
 
     def is_angle_inside(self, alpha, rtol=1e-03, atol=1e-03,
@@ -889,7 +925,7 @@ class Arc(Circle):
         self.startangle = np.arctan2(p1[1], p1[0])
         self.endangle = np.arctan2(p2[1], p2[0])
         if self.rtheta is not None:
-            self.rtheta = self.rtheta + alpha
+            self.rtheta = self.rtheta + dest_alpha
         return self
 
     def minmax(self):
@@ -1054,6 +1090,9 @@ class Line(Shape):
         self.n1 = None
         self.n2 = None
 
+    def classname(self):
+        return "Line"
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -1186,6 +1225,14 @@ class Line(Shape):
             return split_lines
         return []
 
+    def cut_into_halves(self):
+        """ return two lines
+        """
+        pm = middle_point_of_line(self.p1, self.p2)
+        l1 = Line(Element(start=self.p1, end=pm))
+        l2 = Line(Element(start=pm, end=self.p2))
+        return l1, l2
+
     def concatenate_line(self, n1, n2, el):
         if np.isclose(self.m(999999.0), el.m(999999.0)):
             return Line(Element(start=n1, end=n2))
@@ -1293,6 +1340,9 @@ class Point(Shape):
     def __init__(self, p):
         self.p1 = p
 
+    def classname(self):
+        return "Point"
+
     def render(self, renderer):
         renderer.point(self.p1)
 
@@ -1301,6 +1351,7 @@ class Point(Shape):
         self.p1 = (n[0], n[1])
         return self
 
+
 def is_Circle(e):
     return isinstance(e, Circle) and not isinstance(e, Arc)
 

femagtools/femag.py

@@ -90,7 +90,7 @@ def get_shortCircuit_parameters(bch, nload):
             fc_radius=bch.machine['fc_radius'],
             lfe=bch.armatureLength/1e3,
             pocfilename=bch.machine['pocfile'],
-            num_par_wdgs=bch.machine['num_par_wdgs'],
+            num_par_wdgs=bch.machine.get('num_par_wdgs', 0),
             calculationMode='shortcircuit')
     except (KeyError, AttributeError, IndexError):
         raise FemagError("missing pm/Rel-Sim results")
@@ -222,6 +222,12 @@ class BaseFemag(object):
             pass
         builder = femagtools.fsl.Builder(self.templatedirs)
         if simulation:
+            if 'num_par_wdgs' not in simulation:
+                try:
+                    num_par_wdgs = self.model.winding['num_par_wdgs']
+                    simulation['num_par_wdgs'] = num_par_wdgs
+                except:
+                    pass
             set_magnet_properties(self.model, simulation, self.magnets)
             return builder.create(self.model, simulation,
                                   self.magnets, self.condMat)
@@ -351,6 +357,16 @@ class BaseFemag(object):
 
     def readResult(self, simulation, bch=None):
         if simulation:
+            if simulation['calculationMode'] == "fieldcalc":
+                nc = self.read_nc()
+                pmod = nc.poles_sim
+                r = {'airgap': ag.read(
+                    os.path.join(self.workdir, 'bag.dat'), pmod=pmod)}
+                if 'plots' in simulation:
+                    if 'field_lines' in simulation['plots']:
+                        r['field_lines'] = os.path.join(
+                            self.workdir, 'field.svg')
+                return r
             if simulation['calculationMode'] == "pm_sym_loss":
                 return self.read_los(self.modelname)
 
@@ -365,7 +381,8 @@ class BaseFemag(object):
 
             if simulation['calculationMode'] == 'therm-dynamic':
                 temp = [[float(n) for n in l.split()]
-                        for l in (pathlib.Path(self.workdir) / 'temperature.dat').read_text().split('\n') if l]
+                        for l in (pathlib.Path(self.workdir) /
+                                  'temperature.dat').read_text().split('\n') if l]
                 ttemp = list(zip(*temp))
                 return {'t': ttemp[0], 'temperature': ttemp[1]}
 
@@ -383,9 +400,10 @@ class BaseFemag(object):
                     set_magnet_properties(self.model, simulation, self.magnets)
                     fslcmds = (builder.open_model(self.model) +
                                builder.create_shortcircuit(simulation))
+                    fslfile = 'shortcicuit.fsl'
                     with open(os.path.join(self.workdir, fslfile), 'w') as f:
                         f.write('\n'.join(fslcmds))
-                    self.run(fslfile, options)
+                    self.run(fslfile) #, options?
                     bchfile = self.get_bch_file(self.modelname)
                     if bchfile:
                         bchsc = femagtools.bch.Reader()

femagtools/fsl.py

@@ -484,7 +484,11 @@ class Builder:
         if not hasattr(model, 'stator'):
             setattr(model, 'stator', {})
         model.stator['num_slots'] = conv.get('tot_num_slot')
-        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'])
@@ -633,15 +637,23 @@ class Builder:
 
     def create_analysis(self, sim):
         pfefunc = sim.get('loss_funct', '')
+        custom_fefunc = ['']
         if pfefunc:
             sim['loss_funct'] = 1 # 3?
+            if pfefunc == 'bertotti' or 'modified_steinmetz':
+                custom_fefunc = self.__render(sim['PVFE_FSL'], pfefunc)
+            else:
+                custom_fefunc = pfefunc.split('\n')
+
         airgap_induc = (self.create_airgap_induc()
                         if sim.get('airgap_induc', 0) else [])
-        felosses = pfefunc.split('\n') + self.create_fe_losses(sim)
+        felosses = custom_fefunc + self.create_fe_losses(sim)
         fslcalc = (self.__render(sim, sim.get('calculationMode')) +
                    airgap_induc)
+        '''
         if pfefunc:
             sim['loss_funct'] = pfefunc
+        '''
 
         if sim.get('calculationMode') in ('cogg_calc',
                                           'ld_lq_fast',

femagtools/machine/__init__.py

@@ -14,13 +14,14 @@ import logging
 logger = logging.getLogger(__name__)
 
 
-def __scale_losses(losses, lfe):
+def __scale_losses(losses, rlfe):
     if losses:
-        l = {k: lfe*np.array(losses[k]) for k in (
+        l = {k: rlfe*np.array(losses[k]) for k in (
             'styoke_hyst', 'styoke_eddy',
             'stteeth_hyst', 'stteeth_eddy',
+            'styoke_excess', 'stteeth_excess', 'rotor_excess',
             'rotor_hyst', 'rotor_eddy',
-            'magnet')}
+            'magnet') if k in losses}
         l['speed'] = losses['speed']
         return l
     return {}
@@ -66,18 +67,15 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
 
         psid = rwdg*rlfe*dqp['psid']
         psiq = rwdg*rlfe*dqp['psiq']
-        try:
-            losses = __scale_losses(dqp['losses'], rlfe)
-            losses['ef'] = dqpars[-1]['losses']['ef']
-            losses['eh'] = dqpars[-1]['losses']['ef']
-        except KeyError as e:
-            logger.warning(e)
-            losses = {}
+        losses = __scale_losses(dqp['losses'], rlfe)
+        losses['ef'] = dqpars[-1]['losses']['ef']
+        losses['eh'] = dqpars[-1]['losses']['ef']
+
         if 'psidq' in eecpars:
             machine = PmRelMachinePsidq(
                 eecpars['m'], eecpars['p'],
-                r1=eecpars['r1']*rlfe*rwdg**2,
-                ls=eecpars['ls1']*rwdg**2,
+                r1=eecpars.get('r1', 0)*rlfe*rwdg**2,
+                ls=eecpars.get('ls1', 0)*rwdg**2,
                 psid=psid,
                 psiq=psiq,
                 losses=losses,
@@ -90,8 +88,8 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
             i1 = np.array(dqp['i1'])/rwdg
             machine = PmRelMachineLdq(
                 eecpars['m'], eecpars['p'],
-                r1=eecpars['r1']*rlfe*rwdg**2,
-                ls=eecpars['ls1']*rwdg**2,
+                r1=eecpars.get('r1', 0)*rlfe*rwdg**2,
+                ls=eecpars.get('ls1', 0)*rwdg**2,
                 psid=psid,
                 psiq=psiq,
                 losses=losses,
@@ -103,7 +101,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
 
     # must be an induction machine (TODO: check scaling)
     pars = copy.deepcopy(eecpars)
-    pars['r1'] = rlfe*rwdg**2*pars['r1']
+    pars['r1'] = rlfe*rwdg**2*pars.get('r1', 0)
     pars['lsigma1'] = rlfe*pars['lsigma1']
     pars['lsigma2'] = rlfe*pars['lsigma2']
     pars['psiref'] = rwdg*rlfe*pars['psiref']
@@ -119,24 +117,6 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     return InductionMachine(pars)
 
 
-def __scale_losses(losses, rlfe):
-    if losses:
-        l = {k: rlfe*np.array(losses[k]) for k in (
-            'styoke_hyst', 'styoke_eddy',
-            'stteeth_hyst', 'stteeth_eddy',
-            'rotor_hyst', 'rotor_eddy',
-            'magnet')}
-        if 'styoke_exc' in losses:
-            l.update({k: rlfe*np.array(losses[k]) 
-                        for k in (
-                            'styoke_exc',
-                            'stteeth_exc', 
-                            'rotor_exc')})
-        l['speed'] = losses['speed']
-        return l
-    return {}
-
-
 def create(bch, r1, ls, lfe=1, wdg=1):
     """create PmRelMachine from BCH
 

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)