femagtools 1.8.16__py3-none-any.whl → 1.8.18__py3-none-any.whl

femagtools/femag.py

@@ -79,6 +79,7 @@ def set_magnet_properties(model, simulation, magnets):
         magn_temp = simulation.magn_temp
     if 'material' not in model.magnet:
         return
+
     try:
         material = model.magnet['material']
         magnetMat = magnets.find(material)
@@ -95,19 +96,24 @@ def set_magnet_properties(model, simulation, magnets):
                 tempcoefmuer = (tempcoefbr-tempcoefhc)/(1+tempcoefhc*(magn_temp-20))
             if 'temcoefmuer' in magnetMat:
                 tempcoefmuer = magnetMat['temcoefmuer']
-            hcj = magnetMat.get('HcJ', 0)
-            if hcj:
-                model.hc_min = -hcj * (1+tempcoefhc*(magn_temp-20))
+            if not hasattr(model, 'hc_min'):
+                for k in 'Hk', 'HcJ':
+                    if k in magnetMat:
+                        hcmin = magnetMat.get(k)
+                        model.hc_min = hcmin * (1+tempcoefhc*(magn_temp-20))
+                        break
+            if hasattr(model, 'hc_min'):
+                logger.info("hc_min %f", model.hc_min)
             model.magnet['temp_prop']['relperm'] = \
                 (1+tempcoefmuer*(magn_temp-20))*relperm
             if tempcoefbr:
                 model.magnet['temp_prop']['temcoefbr'] = tempcoefbr
             if tempcoefhc:
                 model.magnet['temp_prop']['temcoefhc'] = tempcoefhc
-
     except AttributeError:
         pass
 
+
 class BaseFemag(object):
     def __init__(self, workdir, cmd, magnetizingCurves, magnets, condMat,
                  templatedirs=[]):
@@ -415,7 +421,8 @@ class BaseFemag(object):
         except FileNotFoundError:
             pass
 
-        return list(pathlib.Path(self.workdir).glob('*.PROT'))[0].stem
+        return sorted(pathlib.Path(self.workdir).glob('*.PROT'),
+                      key=lambda x: x.stat().st_mtime, reverse=True)[0].stem
 
     def readResult(self, machine, simulation, bch=None):
         if simulation:
@@ -460,14 +467,6 @@ class BaseFemag(object):
 
             if not bch:
                 bch = self.read_bch(self.modelname)
-            if simulation['calculationMode'] == 'pm_sym_fast' or \
-                simulation['calculationMode'] == 'torq_calc':
-                if simulation.get('shortCircuit', False):
-                    from .shortcircuit import shortcircuit
-                    set_magnet_properties(self.model, simulation, self.magnets)
-                    bch.scData = shortcircuit(self, machine, bch, simulation)
-                    #bch.torque += bchsc.torque
-                    #bch.demag += bchsc.demag
 
             if 'airgap_induc' in simulation:
                 try:
@@ -477,6 +476,19 @@ class BaseFemag(object):
                 bch.airgap = ag.read(os.path.join(self.workdir, 'bag.dat'),
                                      pmod=pmod)
 
+            if simulation['calculationMode'] == 'pm_sym_fast' or \
+                simulation['calculationMode'] == 'torq_calc':
+                if simulation.get('shortCircuit', False):
+                    from .shortcircuit import shortcircuit
+                    set_magnet_properties(self.model, simulation, self.magnets)
+                    bch.scData = shortcircuit(self,
+                                              {'name': self.model.name,
+                                               'poles': self.model.poles,
+                                               'hc_min': self.model.get('hc_min', 0)},
+                                               bch, simulation)
+                    #bch.torque += bchsc.torque
+                    #bch.demag += bchsc.demag
+
             if simulation.get('magnet_loss', False):
                 logger.info('Evaluating magnet losses...')
                 ops = range(len(bch.torque))
@@ -490,7 +502,7 @@ class BaseFemag(object):
 
                 if len(ops) != len(bch.losses):
                     magn_losses.insert(0, magn_losses[0])
-                
+
                 magn_losses = [float(i) for i in magn_losses]
                 try:
                     for i in range(len(bch.losses)):
@@ -600,10 +612,9 @@ class Femag(BaseFemag):
                 os.remove(f)
 
     def __call__(self, machine, simulation={},
-                 options=['-b'], fsl_args=[]):
+                 options=['-b'], fsl_args=[], fslfile='femag.fsl'):
         """setup fsl file, run calculation and return
         BCH, ASM, TS or LOS results if any."""
-        fslfile = 'femag.fsl'
         with open(os.path.join(self.workdir, fslfile), 'w') as f:
             f.write('\n'.join(self.create_fsl(machine,
                                               simulation)))

femagtools/machine/__init__.py

@@ -51,6 +51,8 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
             smpars = copy.deepcopy(eecpars)
             smpars['tcu1'] = temp[0]
             smpars['tcu2'] = temp[1]
+            # external inductances 
+            opts["ls"] = eecpars.get('ls1', 0)*rwdg**2
             if 'ldq' in smpars:
                 machine = SynchronousMachineLdq(smpars, lfe=rlfe, wdg=rwdg, **opts)
             else:

femagtools/machine/effloss.py

@@ -252,6 +252,8 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
                 rb['n'] = None
                 rb['T'] = None
         if 'n' not in rb:
+            if kwargs.get('i1max', 0):
+                kwargs['i1max'] = -kwargs['i1max']
             rb = m.characteristics(-T, max(r['n']), u1, nsamples=nsamples,
                                    with_mtpv=with_mtpv, with_mtpa=with_mtpa,
                                    with_pmconst=with_pmconst, with_tmech=with_tmech,
@@ -267,13 +269,17 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         if isinstance(m, (SynchronousMachineLdq, SynchronousMachinePsidq)):
             iq, id, iex = m.iqd_torque(T[-1])
             i1max = betai1(iq, id)[1]
+            if kwargs.get("i1max", 0):
+                i1max = kwargs["i1max"]
             w1type, tmax = m.w1_imax_umax(i1max, u1)
             pmax = tmax*w1type/m.p
         else:
             iq, id = m.iqd_torque(T[-1])
-            w1type, tmax = m.w1_imax_umax(betai1(iq, id)[1], u1)
+            i1max = betai1(iq, id)[1]
+            if kwargs.get("i1max", 0):
+                i1max = kwargs["i1max"]
+            w1type, tmax = m.w1_imax_umax(i1max, u1)
 
-        i1max = betai1(iq, id)[1]
         logger.info("%s %s", n, T)
         for nx in n:
             w1 = 2*np.pi*nx*m.p
@@ -431,7 +437,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
             e = pm / p1
         else:
             e = p1 / pm
-        eta.append(e)
+        eta.append(float(e))
 
     return dict(
         iq=iqd[0].tolist(),
@@ -450,4 +456,4 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plfric=plfric.tolist(),
         losses=ploss.tolist(),
         plcu1_dc=plcu1_dc,
-        plcu1_ac=plcu1_ac)
+        plcu1_ac=plcu1_ac)

femagtools/machine/pm.py

@@ -182,6 +182,8 @@ class PmRelMachine(object):
             return (0, 0)
         if np.isscalar(iqd0):
             i0 = self.io
+            if torque<0:
+                i0[0] = -i0[0]
         else:
             i0 = iqd0
         if with_mtpa:
@@ -193,10 +195,14 @@ class PmRelMachine(object):
             if res.success:
                 #raise ValueError(f'Torque {torque}, io {i0}: {res.message}')
                 return res.x
+            # should not happen
             def func(i1):
                 return torque - self.mtpa(i1)[2]
+#            with warnings.catch_warnings():
+#                warnings.simplefilter("error")
             i1 = so.fsolve(func, res.x[0])[0]
             return self.mtpa(i1)[:2]
+
         def func(iq):
             return torque - self.torque_iqd(iq, 0)
         return so.fsolve(func, 0)[0]
@@ -220,7 +226,7 @@ class PmRelMachine(object):
             else:
                 i0 = (iq0, 0)
             logger.debug("initial guess i0 %f -> %s tx %f torque %f",
-                        self.io[0], i0, tx, torque)
+                         self.io[0], i0, tx, torque)
         else:
             i0 = iqd0
 
@@ -237,7 +243,7 @@ class PmRelMachine(object):
                 # make new initial guess:
                 tx = self.tmech_iqd(*i0, n)
                 logger.debug("k %d new guess i0 %s tx %f torque %f",
-                            k, i0, tx, torque)
+                             k, i0, tx, torque)
                 i0=(min(0.9*self.i1range[1]/np.sqrt(2), torque/tx*i0[0]), 0)
                 k += 1
             raise ValueError(
@@ -247,39 +253,6 @@ class PmRelMachine(object):
         iq = so.fsolve(tqiq, (i0[0],))[0]
         return iq, 0, self.tmech_iqd(iq, 0, n)
 
-    def iqd_tmech0(self, torque, n, iqd0=0, with_mtpa=True):
-        """return minimum d-q-current for shaft torque"""
-        if np.abs(torque) < 1e-2:
-            return (0, 0)
-        if np.isscalar(iqd0):
-            i0 = self.io
-        else:
-            i0 = iqd0
-
-        if with_mtpa:
-            res = so.minimize(
-                lambda iqd: la.norm(iqd), i0, method='SLSQP',
-                constraints=({'type': 'eq',
-                              'fun': lambda iqd:
-                              self.tmech_iqd(*iqd, n) - torque}))
-            if res.success:
-                return res.x
-
-            #logger.warning("n: %s, torque %s: %s %s",
-            #                   60*n, torque, res.message, i0)
-            # try a different approach:
-            #raise ValueError(
-            #    f'Torque {torque:.1f} speed {60*n:.1f} {res.message}')
-            def func(i1):
-                return torque - self.mtpa_tmech(i1, n)[2]
-            i1 = so.fsolve(func, res.x[0])[0]
-            return self.mtpa_tmech(i1, n)[:2]
-
-        def tqiq(iq):
-            return torque - self.tmech_iqd(float(iq), 0, n)
-        iq = so.fsolve(tqiq, (i0[0],))[0]
-        return iq, 0, self.tmech_iqd(iq, 0, n)
-
     def tloss_iqd(self, iq, id, n):
         """return loss torque of d-q current, iron loss correction factor
         and friction windage losses"""
@@ -350,12 +323,12 @@ class PmRelMachine(object):
             sign = -1 if i1max > 0 else 1
             res = so.minimize(
                 lambda n: sign*self.tmech_iqd(iq, id, n),
-                    n0,
-                    constraints={
-                        'type': 'eq',
-                        'fun': lambda n:
-                        np.sqrt(2)*u1max - np.linalg.norm(
-                            self.uqd(2*np.pi*n*self.p, iq, id))})
+                n0,
+                constraints={
+                    'type': 'eq',
+                    'fun': lambda n:
+                    np.sqrt(2)*u1max - np.linalg.norm(
+                        self.uqd(2*np.pi*n*self.p, iq, id))})
             return 2*np.pi*res.x[0]*self.p, self.tmech_iqd(iq, id, res.x[0])
 
         return so.fsolve(lambda x: np.linalg.norm(
@@ -453,22 +426,26 @@ class PmRelMachine(object):
             i1 = self.i1_tmech(torque, 0, n)
             i0 = iqd(0, i1)
 
+        logger.debug("i0 %s", i0)
         if np.linalg.norm(self.uqd(w1, *i0))/np.sqrt(2) > u1max:
             beta, i1 = betai1(*i0)
             with warnings.catch_warnings():
                 warnings.simplefilter("ignore")
-                i0 = iqd(so.fsolve(lambda b: u1max - np.linalg.norm(
-                    self.uqd(w1, *iqd(b, i1)))/np.sqrt(2),
-                                   beta)[0], i1)
+                bx, _, ier, msg = so.fsolve(lambda b: u1max - np.linalg.norm(
+                    self.uqd(w1, *iqd(b, i1)))/np.sqrt(2), beta,
+                                          full_output=True)
+                i0 = iqd(bx[0], i1)
+                logger.debug("i0 %s ier %d %s", i0, ier, msg)
 
-            res = so.minimize(lambda iqd: np.linalg.norm(iqd), i0, method='SLSQP',
-                          constraints=(
-                              {'type': 'eq',
-                               'fun': lambda iqd:
-                               self.tmech_iqd(*iqd, n) - torque},
-                              {'type': 'ineq',
-                               'fun': lambda iqd:
-                               np.sqrt(2)*u1max - la.norm(self.uqd(w1, *iqd))}))
+            res = so.minimize(
+                lambda iqd: np.linalg.norm(iqd), i0, method='SLSQP',
+                constraints=(
+                    {'type': 'eq',
+                     'fun': lambda iqd:
+                     self.tmech_iqd(*iqd, n) - torque},
+                    {'type': 'ineq',
+                     'fun': lambda iqd:
+                     np.sqrt(2)*u1max - la.norm(self.uqd(w1, *iqd))}))
             iq, id = res.x
         else:
             iq, id = i0
@@ -587,18 +564,19 @@ class PmRelMachine(object):
             log((iq, id, tq))
         return iq, id, tq
 
-    def iqd_imax_umax(self, i1max, w1, u1max, torque, with_mtpv=True, with_tmech=True, with_mtpa=True):
+    def iqd_imax_umax(self, i1max, w1, u1max, torque, with_mtpv=True,
+                      with_tmech=True, with_mtpa=True):
         """return d-q current and shaft torque at stator frequency and max voltage
         and max current (for motor operation if maxtorque else generator operation)"""
         if torque > 0:
-            sign=-1
+            sign = -1
             # -pi/2 --> 0
             b0, b1 = max(-np.pi/2, self.betarange[0]), 0
             if max(self.betarange) < b1:
                 raise ValueError(
                     f"invalid betarange for maxtorque>0: {self.betarange}")
         else:
-            sign=1
+            sign = 1
             # -pi/2 --> -pi
             b0, b1 = -np.pi/2, max(-np.pi, self.betarange[0])
             if min(self.betarange) > b0:
@@ -608,6 +586,7 @@ class PmRelMachine(object):
             iq, id, _ = self.mtpa(i1max)
         else:
             iq, id = iqd(0, i1max)
+
         deps = 1e-6
         kmax = 100
 
@@ -622,8 +601,10 @@ class PmRelMachine(object):
             else:
                 iq, id, tq = self.iqd_torque_umax(torque, w1, u1max)
             if not with_mtpv:
+                logging.debug("not mtpv iq %f id %f tq %f",
+                             iq, id, tq)
                 return iq, id, tq
-            beta, i1 = betai1(iq, id)
+            #beta, i1 = betai1(iq, id)
         else:
             for k in range(kmax):
                 bx = b0 + (b1-b0)/2
@@ -642,9 +623,9 @@ class PmRelMachine(object):
             if abs(du) > 0.1:
                 logger.debug('oops? iqd_imax_umax one more torque reduction')
                 if with_tmech:
-                    iq, id = self.iqd_tmech_umax(torque, w1, u1max)[:2]
+                    iq, id, tq = self.iqd_tmech_umax(torque, w1, u1max)
                 else:
-                    iq, id = self.iqd_torque_umax(torque, w1, u1max)[:2]
+                    iq, id, tq = self.iqd_torque_umax(torque, w1, u1max)
         if with_mtpv:
             try:
                 if with_tmech:
@@ -656,9 +637,26 @@ class PmRelMachine(object):
                     iq, id, tq = self.mtpv(w1, u1max, iqd0=(iq, id),
                                            maxtorque=torque>0,
                                            i1max=i1max)
+                logging.debug("mtpv iq %f id %f tq %f",
+                              iq, id, tq)
                 return iq, id, tq
             except ValueError as e:
-                logger.debug(e)
+                n = w1/2/np.pi/self.p
+                logger.debug(" i1max %f iq %f id %f", i1max, iq, id)
+                #
+                res = so.minimize(
+                    lambda iqd: sign*self.tmech_iqd(*iqd, n),
+                    (iq, id),
+                    constraints=[{
+                        'type': 'eq',
+                        'fun': lambda iqd:
+                        np.sqrt(2)*u1max - np.linalg.norm(
+                            self.uqd(w1, *iqd))}])
+                logger.debug(" n %f i1max %f %f iq %f id %f tq %f",
+                            60*n, i1max, np.linalg.norm(res.x)/np.sqrt(2),
+                            iq, id, sign*res.fun)
+                if res['success'] and abs(i1max*np.sqrt(2)) >= np.linalg.norm(res.x):
+                    return *res.x, sign*res.fun
 
         if with_tmech:
             tq = self.tmech_iqd(iq, id, w1/2/np.pi/self.p)
@@ -723,6 +721,8 @@ class PmRelMachine(object):
         else:
             i0 = iqd0
         n = w1/2/np.pi/self.p
+        logger.debug("w1 %f u1 %f iqd0 %s maxtorque %s %f",
+                    w1, u1, iqd0, maxtorque, i1max)
         constraints=[{'type': 'eq',
                      'fun': lambda iqd:
                      np.sqrt(2)*u1 - la.norm(
@@ -734,6 +734,7 @@ class PmRelMachine(object):
         res = so.minimize(lambda iqd: sign*self.tmech_iqd(*iqd, n), i0,
                           method='SLSQP',
                           constraints=constraints)
+        logger.debug("iq %f id %f w1 %f success %s", res.x[0], res.x[1], w1, res['success'])
         if res['success']:
             return res.x[0], res.x[1], sign*res.fun
         #logger.warning("w1=%.1f u1=%.1f maxtorque=%s %s: %s", w1, u1, maxtorque, res.x, res.message)
@@ -814,7 +815,7 @@ class PmRelMachine(object):
         if (abs(i1max) >= i1
             and round(u1max, 1) >= round(np.linalg.norm(
                 self.uqd(w1max, iq, id)/np.sqrt(2)), 1)):
-            return [w1type/2/np.pi/self.p, speedmax]
+            return [float(w1type/2/np.pi/self.p), float(speedmax)]
         wl, wu = [w1type, min(4*w1type, w1max)]
         if with_mtpv:
             kmax = 6
@@ -835,6 +836,7 @@ class PmRelMachine(object):
                                                 T, with_mtpa=with_mtpa,
                                                 with_mtpv=False)[:2]
                 i1 = betai1(iq, id)[1]
+                logger.debug("iq %f id %f i1 %f", iq, id, i1)
                 try:
                     if with_tmech:
                         def voltw1(wx):
@@ -851,7 +853,7 @@ class PmRelMachine(object):
                     if ier == 1: #in (1, 4, 5):
                         if abs(w[0]) <= wx:
                             self.check_extrapolation = True
-                            return [w/2/np.pi/self.p
+                            return [float(w/2/np.pi/self.p)
                                     for w in (w1type, w[0], w1max)]  # ['MTPA', 'MTPV']
                         if w[0] > wu:
                             wl += (wu-wl)/4
@@ -873,7 +875,7 @@ class PmRelMachine(object):
         self.check_extrapolation = True
         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']
+        return [float(w/2/np.pi/self.p) for w in (w1type, w1max)]  # ['MTPA']
 
 
     def operating_point(self, T, n, u1max, with_mtpa=True):
@@ -990,8 +992,8 @@ class PmRelMachine(object):
         if kwargs.get('i1max', 0):
             i1max = kwargs['i1max']
             w1, Tf = self.w1_imax_umax(i1max, u1max,
-                                      with_mtpa=with_mtpa,
-                                      with_tmech=with_tmech)
+                                       with_mtpa=with_mtpa,
+                                       with_tmech=with_tmech)
             if with_mtpa:
                 iq, id, T = self.mtpa(i1max)
             else:
@@ -1026,7 +1028,8 @@ class PmRelMachine(object):
                     iq, id = iqd(0, i1max)
 
                 if with_tmech:
-                    w1, Tf = self.w1_imax_umax(i1max, u1max, with_mtpa=with_mtpa,
+                    w1, Tf = self.w1_imax_umax(i1max, u1max,
+                                               with_mtpa=with_mtpa,
                                                with_tmech=with_tmech)
                 else:
                     iq, id = self.iqd_torque(T)
@@ -1100,14 +1103,15 @@ class PmRelMachine(object):
                                     iq, id, tq = self.iqd_imax_umax(
                                         i1max, w1, u1max,
                                         tq, with_tmech=with_tmech,
-                                        with_mtpv=with_mtpv,
                                         with_mtpa=with_mtpa)
                             else:
                                 if with_tmech:
                                     iq, id, tq = self.mtpv_tmech(w1, u1max,
+                                                                 iqd0=(iq, id),
                                                                  maxtorque=T > 0)
                                 else:
                                     iq, id, tq = self.mtpv(w1, u1max,
+                                                           iqd0=(iq, id),
                                                            maxtorque=T > 0)
                             if (T > 0 and tq > 0) or (T < 0 and tq < 0):
                                 r['id'].append(id)
@@ -1115,8 +1119,8 @@ class PmRelMachine(object):
                                 r['n'].append(nn)
                                 r['T'].append(tq)
                             else:
-                                logger.warning("fieldweakening: n %g T %g tq %g i1max %g w1 %g u1 %g",
-                                               nn*60, T, tq, i1max, w1, u1max)
+                                logger.debug("fieldweakening: n %g T %g tq %g i1max %g w1 %g u1 %g",
+                                             nn*60, T, tq, i1max, w1, u1max)
                     except ValueError as e:
                         nmax = r['n'][-1]
                         logger.warning("%s: adjusted nmax %f T %f", e, nmax, r['T'][-1])

femagtools/machine/sm.py

@@ -126,7 +126,7 @@ def parident(workdir, engine, machine,
         period_frac=kwargs.get('period_frac', 6),
         speed=kwargs.get('speed', 50))
 
-    if kwargs.get("feloss", 0): 
+    if kwargs.get("feloss", 0):
         simulation["feloss"] = kwargs["feloss"]
         machine["calc_fe_loss"] = loss_models[kwargs["feloss"].lower()]
     ###self.cleanup()  # remove previously created files in workdir
@@ -413,8 +413,8 @@ class SynchronousMachine(object):
     def uqd(self, w1, iq, id, iex):
         """return uq, ud of frequency w1 and d-q current"""
         psid, psiq = self.psi(iq, id, iex)
-        r1 = self.rstat(w1)
-        return r1*iq + w1*psid, r1*id - w1*psiq
+        # r1 = self.rstat(w1)
+        return self.r1*iq + w1*(self.ls*id + psid), self.r1*id - w1*(self.ls*iq + psiq)
 
     def plcu1(self, iqde, w1):
         r1 = self.rstat(w1)
@@ -458,9 +458,9 @@ class SynchronousMachine(object):
             #options={'disp': disp, 'maxiter': maxiter})
             if res['success']:
                 return res.x
-            else: 
+            else:
                 res = so.minimize(
-                    lambda cur: (self.tmech_iqd(*cur, n) - torque)**2, res.x, method='SLSQP', 
+                    lambda cur: (self.tmech_iqd(*cur, n) - torque)**2, res.x, method='SLSQP',
                     bounds=self.bounds,
                 )
                 if res['success']:
@@ -548,10 +548,10 @@ class SynchronousMachine(object):
             log(res.x)
         if res["success"]:
             return *res.x, self.tmech_iqd(*res.x, n)
-        else: 
+        else:
             # didn't converge, fullfill voltage and torque demand
             res = so.minimize(
-                lambda cur: (self.tmech_iqd(*cur, n) - torque)**2, io, method='SLSQP', 
+                lambda cur: (self.tmech_iqd(*cur, n) - torque)**2, io, method='SLSQP',
                 bounds=self.bounds,
                 constraints=[
                 {'type': 'eq',
@@ -562,8 +562,8 @@ class SynchronousMachine(object):
                 return *res.x, self.tmech_iqd(*res.x, n)
             else:
                 res = so.minimize(
-                    lambda cur: (self.tmech_iqd(*cur, n) - torque)**2 + 
-                    (np.linalg.norm(self.uqd(w1, *cur)) - u1max*np.sqrt(2))**2, io, method='SLSQP', 
+                    lambda cur: (self.tmech_iqd(*cur, n) - torque)**2 +
+                    (np.linalg.norm(self.uqd(w1, *cur)) - u1max*np.sqrt(2))**2, io, method='SLSQP',
                     bounds=self.bounds,
                 )
                 return *res.x, self.tmech_iqd(*res.x, n)
@@ -680,7 +680,7 @@ class SynchronousMachine(object):
             Tf = T
             w1type = self.w1_umax(u1max, iq, id, iex)
         logger.debug("w1type %f", w1type)
-        wmType = w1type/self.p
+        wmType = float(w1type/self.p)
         pmax = Tf*wmType
 
         def tload(wm):
@@ -723,7 +723,7 @@ class SynchronousMachine(object):
                     iq, id, iex, tqx = self.iqd_torque_umax(
                             tq, w1, u1max)
                     tqx -= self.tfric
-            else: 
+            else:
                 tqx = Tf
 
             uq, ud = self.uqd(w1, iq, id, iex)
@@ -857,9 +857,9 @@ class SynchronousMachinePsidq(SynchronousMachine):
                 'rotor_hyst', 'rotor_eddy')}
 
     def set_max_iex(self, iexc):
-        self.bounds[-1] = (self.bounds[-1][0], iexc) 
+        self.bounds[-1] = (self.bounds[-1][0], iexc)
         self.exc_max = iexc
-        
+
     def psi(self, iq, id, iex):
         """return psid, psiq of currents iq, id"""
         try:
@@ -980,9 +980,9 @@ class SynchronousMachineLdq(SynchronousMachine):
                 'styoke_eddy', 'stteeth_eddy',
                 'rotor_hyst', 'rotor_eddy')}
             pass
-    
+
     def set_max_iex(self, iexc):
-        self.bounds[-1] = (self.bounds[-1][0], iexc) 
+        self.bounds[-1] = (self.bounds[-1][0], iexc)
         self.exc_max = iexc
 
     def psi(self, iq, id, iex):

femagtools/plot/bch.py

@@ -515,10 +515,12 @@ def cogging(bch, title=''):
         fig.subplots_adjust(top=0.92)
 
 
-def demagnetization(demag, ax=0):
+def demagnetization(demag, title='', ax=0):
     """plot rel. remanence vs. current"""
     if ax == 0:
         ax = plt.gca()
+    if title:
+        ax.set_title(title)
     scale = 1
     unit = 'A'
     if np.max(demag['i1']) > 25e3:

femagtools/plot/char.py

@@ -304,23 +304,12 @@ def _plot_contour(speed, torque, z, ax, title='', levels=[],
     y, yscale = _normalize10(y, **kwargs)
 
     if not levels:
+        levels = [0.5, 0.7, 0.8]
         if max(z) <= 1:
-            if max(z) > 0.96:
-                #levels = [0.5, 0.75, 0.8, 0.84,
-                          #0.89, 0.92, 0.94, 0.96, 0.97]
-                levels = np.linspace(min(z),max(z),9)
-                levels = np.round(levels, 2)
-                levels = list(levels)
-
-            else:
-                #levels = [0.25, 0.5, 0.75, 0.8, 0.84,
-                         #0.88, 0.9, 0.92, 0.94, 0.96]
-                levels = np.linspace(min(z),max(z),9)
-                levels = np.round(levels, 2)
-                levels = list(levels)
-
-            if max(z) > levels[-1]:
-                levels.append(np.ceil(max(z)*100)/100)
+            a = np.array(z)
+            zmax = np.ceil(100*np.max(z))/100
+            levels += [zmax - x for x in
+                       [0.07, 0.05, 0.03, 0.02, 0.01, 0]]
         else:
             levels = 14
     #