femagtools 1.8.17__py3-none-any.whl → 1.8.19__py3-none-any.whl

femagtools/machine/pm.py

@@ -97,7 +97,7 @@ class PmRelMachine(object):
         self.zeta1 = 0.2
         self.gam = 0.7
         self.kh = 2
-        self.kpfe = 1 # iron loss factor
+        self.kpfe = 1 # common iron loss factor
         self.kpmag = 1 # magnet loss factor
         self.kfric_b = 1
         self.rotor_mass = 0
@@ -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,45 +253,18 @@ 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"""
         if n > 1e-3:
             f1 = self.p*n
-            plfe = self.kpfe * (self.iqd_plfe1(iq, id, f1) + self.iqd_plfe2(iq, id, f1))
+            plfe1 = self.kpfe * self.iqd_plfe1(iq, id, f1)
+            plfe2 = self.kpfe * self.iqd_plfe2(iq, id, f1)
+            if hasattr(self, 'kpfe_s'):
+                plfe1 = self.kpfe_s * self.iqd_plfe1(iq, id, f1)
+            if hasattr(self, 'kpfe_r'):
+                plfe2 = self.kpfe_r * self.iqd_plfe2(iq, id, f1)
+            plfe = plfe1 + plfe2
             pmag = self.kpmag * self.iqd_plmag(iq, id, f1)
             return (plfe + pmag + self.pfric(n))/(2*np.pi*n)
         return 0
@@ -350,12 +329,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 +432,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 +570,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 +592,7 @@ class PmRelMachine(object):
             iq, id, _ = self.mtpa(i1max)
         else:
             iq, id = iqd(0, i1max)
+
         deps = 1e-6
         kmax = 100
 
@@ -622,8 +607,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 +629,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 +643,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 +727,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 +740,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 +821,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 +842,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 +859,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 +881,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):
@@ -925,10 +933,10 @@ class PmRelMachine(object):
         plfe1 = self.iqd_plfe1(iq, id, f1)
         plfe2 = self.iqd_plfe2(iq, id, f1)
         plmag = self.iqd_plmag(iq, id, f1)
-        plfe = plfe1 + plfe2 + plmag
+        plfe = plfe1 + plfe2
         plfric = self.pfric(n)
         plcu = self.betai1_plcu(i1, 2 * np.pi * f1)
-        pltotal = plfe + plcu + plfric
+        pltotal = plfe + plcu + plfric + plmag
         p1 = pmech + pltotal
         if np.abs(pmech) < 1e-12:
             eta = 0  # power to low for eta calculation
@@ -990,8 +998,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 +1034,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 +1109,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 +1125,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])
@@ -1149,11 +1159,15 @@ class PmRelMachine(object):
         f1 = np.array(r['n'])*self.p
         plfe1 = self.kpfe*self.iqd_plfe1(np.array(r['iq']), np.array(r['id']), f1)
         plfe2 = self.kpfe*self.iqd_plfe2(np.array(r['iq']), np.array(r['id']), f1)
+        if hasattr(self, 'kpfe_s'):
+            plfe1 = self.kpfe_s*self.iqd_plfe1(np.array(r['iq']), np.array(r['id']), f1)
+        if hasattr(self, 'kpfe_r'):
+            plfe2 = self.kpfe_r*self.iqd_plfe2(np.array(r['iq']), np.array(r['id']), f1)
         plmag = self.kpmag*self.iqd_plmag(np.array(r['iq']), np.array(r['id']), f1)
-        plfe = plfe1 + plfe2 + plmag
+        plfe = plfe1 + plfe2
         plcu = self.betai1_plcu(np.array(r['i1']), 2*np.pi*f1)
         plfw = self.pfric(2*np.pi*f1)
-        pltotal = plfe + plcu + plfw
+        pltotal = plfe + plcu + plfw + plmag
         r['pmech'] = pmech.tolist()
         r['plfe'] = plfe.tolist()
         r['plcu'] = plcu.tolist()

femagtools/machine/sm.py

@@ -22,7 +22,7 @@ eecdefaults = {
     'tcu2': 20,
     'rotor_mass': 0,
     'kfric_b': 1,
-    'kpfe': 1 # iron loss factor
+    'kpfe': 1 # common iron loss factor
 }
 
 logger = logging.getLogger('sm')
@@ -76,7 +76,13 @@ def parident(workdir, engine, machine,
             raise ValueError('i1_max missing')
         i1_max = kwargs['i1_max']
 
-    ifnom = machine['rotor']['ifnom']
+
+    if "magnetFsl" in machine["magnet"]:
+        rotorkey = "magnet"
+    else:
+        rotorkey = "rotor"
+
+    ifnom = machine[rotorkey]['ifnom']
     exc_logspace = True
     ifmin, ifmax = ifnom/4, 1.4*ifnom
     if exc_logspace:
@@ -126,7 +132,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
@@ -197,7 +203,7 @@ def parident(workdir, engine, machine,
     if simulation['calculationMode'] == 'ld_lq_fast':
         dqpars = dict(m=3, p=b['machine']['p'],
                       r1=float(r1),
-                      r2=machine['rotor'].get('resistance', 1),
+                      r2=machine[rotorkey].get('resistance', 1),
                       rotor_mass=rotor_mass, kfric_b=1,
                       ldq=[dict(
                           ex_current=b['machine']['ex_current'],
@@ -214,7 +220,7 @@ def parident(workdir, engine, machine,
     else:
         dqpars = dict(m=3, p=b['machine']['p'],
                       r1=r1,
-                      r2=machine['rotor'].get('resistance', 1),
+                      r2=machine[rotorkey].get('resistance', 1),
                       rotor_mass=rotor_mass, kfric_b=1,
                       psidq=[dict(
                           ex_current=b['machine']['ex_current'],
@@ -387,8 +393,13 @@ class SynchronousMachine(object):
             and friction windage losses"""
         if n > 1e-3:
             f1 = self.p*n
-            plfe = self.kpfe * (self.iqd_plfe1(iq, id, iex, f1)
-                                + self.iqd_plfe2(iq, id, iex, f1))
+            plfe1 = self.kpfe * self.iqd_plfe1(iq, id, iex, f1)
+            plfe2 = self.kpfe * self.iqd_plfe2(iq, id, iex, f1)
+            if hasattr(self, 'kpfe_s'):
+                plfe1 = self.kpfe_s * self.iqd_plfe1(iq, id, iex, f1)
+            if hasattr(self, 'kpfe_r'):
+                plfe2 = self.kpfe_r * self.iqd_plfe2(iq, id, iex, f1)
+            plfe = plfe1 + plfe2
             return (plfe + self.pfric(n))/(2*np.pi*n)
         return 0
 
@@ -413,8 +424,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 +469,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 +559,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 +573,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 +691,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 +734,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 +868,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 +991,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/mcv.py

@@ -1173,7 +1173,10 @@ class MagnetizingCurve(object):
         mcv = self.find_by_name(name)
         if not mcv:
             bname = name
-            filename = ''.join((name, ext))
+            filename = name if pathlib.Path(name).suffix.upper() == ext \
+                else ''.join((name, ext))
+            if name == 'dummy':
+                return filename
             # check fillfac and readmcv
             if not fillfac or fillfac == 1.0:
                 try:

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
     #