femagtools 1.8.6__py3-none-any.whl → 1.8.8__py3-none-any.whl

femagtools/mcv.py

@@ -99,7 +99,8 @@ def norm_pfe(B, pfe):
                 b = list(b)
                 b[-1] = Bv[n]
                 n += 1
-        pfunc = make_interp_spline(b, pfe[i])
+        k = 3 if len(pfe[i]) > 3 else 2
+        pfunc = make_interp_spline(b, pfe[i], k=k)
         m.append([float(pfunc(x))
                   for x in Bv[:n]] + [None]*(len(Bv)-n))
     return Bv.tolist(), m
@@ -298,6 +299,8 @@ class Mcv(object):
         # {'ch': 0, 'cw': 0, 'ch_freq':0, 'cw_freq':0}
         self.bertotti = {}
         # {'ch': 0, 'cw': 0, 'ce':0, 'ch_freq':0, 'cw_freq':0}
+        self.steinmetz_modified = {}
+        # {'ch': 0, 'cw': 0, 'ch_freq': 1, 'b_beta_coeff': 0, 'cw_freq': 2, 'b_coeff': 2}
         self.MC1_FE_SPEZ_WEIGTH = 7.65
         self.MC1_FE_SAT_MAGNETIZATION = 2.15
 
@@ -359,7 +362,7 @@ class Mcv(object):
         for k in wtrans:
             if wtrans[k] in data.keys():
                 self.__setattr__(k, data[wtrans[k]])
-        for k in ('bertotti', 'jordan', 'steinmetz'):
+        for k in ('bertotti', 'jordan', 'steinmetz', 'steinmetz_modified'):
             if k in data:
                 self.__setattr__(k, data[k])
         self.curve = data['curve']
@@ -374,6 +377,13 @@ class Mcv(object):
         # assume jordan iron loss parameters
         for k in self.jordan:
             self.jordan[k] = getattr(self, transl[k])
+        # set loss coeffs when existing
+        try:
+            for k in ('bertotti', 'jordan', 'steinmetz', 'steinmetz_modified'):
+                if k in data:
+                    self.__setattr__(k, data[k])
+        except:
+            pass
         return
 
     def rtrimValueList(self, vlist):
@@ -489,14 +499,24 @@ class Writer(Mcv):
         feloss: (str) iron loss method (bertotti, jordan)
         """
         curve = self._prepare(fillfac, recsin)
+        write_losses = True
         try:
             if feloss.lower() == 'bertotti':
                 for k in self.bertotti:
                     setattr(self, transl[k], self.bertotti[k])
-                del self.losses
-            else:
+                write_losses = False
+            elif feloss.lower() == 'jordan':
                 for k in self.jordan:
                     setattr(self, transl[k], self.jordan[k])
+                write_losses = False
+            elif feloss.lower() == 'steinmetz':
+                for k in self.steinmetz:
+                    setattr(self, transl[k], self.steinmetz[k])
+                write_losses = False
+            elif feloss.lower() == 'modified steinmetz':
+                for k in self.steinmetz_modified:
+                    setattr(self, transl[k], self.steinmetz_modified[k])
+                write_losses = False
         except AttributeError as e:
             logger.warning("%s", e)
             pass
@@ -578,7 +598,8 @@ class Writer(Mcv):
                 self.writeBlock([self.mc1_angle[K], self.mc1_db2[K]])
 
         try:
-            if not (self.mc1_ch_factor or self.mc1_cw_factor) and self.losses:
+            if (not (self.mc1_ch_factor or self.mc1_cw_factor)
+                and self.losses and write_losses):
                 # fit loss parameters
                 pfe = self.losses['pfe']
                 f = self.losses['f']
@@ -611,12 +632,25 @@ class Writer(Mcv):
                          float(self.mc1_fe_spez_weigth),
                          float(self.mc1_fe_sat_magnetization)])
 
+        logger.info("MCV coeffs %s",
+                    {"fo": float(self.mc1_base_frequency),
+                     "Bo": float(self.mc1_base_induction),
+                     "ch": float(self.mc1_ch_factor),
+                     "cw": float(self.mc1_cw_factor),
+                     "ch_freq": float(self.mc1_ch_freq_factor),
+                     "cw_freq": float(self.mc1_cw_freq_factor),
+                     "b_coeff": float(self.mc1_induction_factor),
+                     "fr_spez_weight": float(self.mc1_fe_spez_weigth),
+                     "fe_sat_magnetization": float(self.mc1_fe_sat_magnetization)})
+
         if not hasattr(self, 'losses') or not self.losses:
             # new variables: ce factor for bertotti losses
             # b_beta_coeff for modified steinmetz
             try:
                 self.writeBlock([float(self.mc1_ce_factor),
                                  float(self.mc1_induction_beta_factor)])
+                #logger.info(f"ce = {float(self.mc1_ce_factor)}")
+                #logger.info(f"b_beta_coeff = {float(self.mc1_induction_beta_factor)}")
             except:
                 pass
             return
@@ -677,13 +711,24 @@ class Writer(Mcv):
                                     [0.0]*(M_LOSS_INDUCT - len(pl)))
                     self.writeBlock(float(f))
                     nrec += 1
-            for m in range(M_LOSS_FREQ - nrec):
-                self.writeBlock([0.0]*M_LOSS_INDUCT)
-                self.writeBlock(0.0)
+
+            if write_losses:
+                logger.info("Append empty blocks %d x %d",
+                            M_LOSS_FREQ - nrec, M_LOSS_INDUCT)
+                for m in range(M_LOSS_FREQ - nrec):
+                    self.writeBlock([0.0]*M_LOSS_INDUCT)
+                    self.writeBlock(0.0)
 
             self.writeBlock([self.losses['cw'], self.losses['cw_freq'],
                              self.losses['b_coeff'], self.losses['fo'],
                              self.losses['Bo']])
+            logger.info("loss coeff %s",
+                        {"cw": float(self.losses['cw']),
+                         "cw_freq": float(self.losses['cw_freq']),
+                         "b_coeff": float(self.losses['b_coeff']),
+                         "fo": float(self.losses['fo']),
+                         "Bo": float(self.losses['Bo'])})
+
             self.writeBlock([1])
             logger.info('Losses n freq %d n ind %d', nfreq, nind)
         except Exception as e:
@@ -1113,7 +1158,7 @@ class MagnetizingCurve(object):
                                 repls.items(), name)
 
     def writefile(self, name, directory='.',
-                  fillfac=None, recsin='', feloss='jordan'):
+                  fillfac=None, recsin='', feloss=''):
         """find magnetic curve by name or id and write binary file
         Arguments:
           name: key of mcv dict (name or id)
@@ -1175,6 +1220,125 @@ class MagnetizingCurve(object):
             losses['fo'] = self.mcv[m]['fo']
 
 
+class MCVconvert:
+    def __init__(self, bhdata):
+        self.steinmetz = dict(cw=0, cw_freq=0, b_coeff=0)
+        self.jordan = dict(ch=0, ch_freq=0, cw=0, cw_freq=0, b_coeff=0)
+        self.bertotti = dict(ch=0, cw=0, ce=0)
+        self.steinmetz_modified = dict(ch=0, cw=0, ch_freq=1, b_beta_coeff=0, cw_freq=2, b_coeff=2)
+        self.losscalc = None
+
+        B = []
+        f = [50.0, 100.0, 200.0, 400.0, 1000.0, 2000.0]
+        pfe = []
+        jordan = False
+        bertotti = False
+        modified_steinmetz = False
+        flag = False
+
+        if "losses" in bhdata:
+            # test if any nan in data
+            for i in ("B", "f"):
+                if np.any(np.isnan(bhdata["losses"][i])) or \
+                np.any(np.isnan(bhdata["losses"][i])):
+                    flag = True
+            for i in bhdata["losses"]['pfe']:
+                if np.any(np.isnan(i)):
+                    flag = True
+
+        if 'losses' not in bhdata or flag:
+            # check steinmetz or jordan
+            bhdata.update({"losses": {"pfe": [], "f":[], "B": []}})
+            B = bhdata["curve"][-1]["bi"]
+            if "ch" in bhdata:
+
+                if "ce" in bhdata:
+                    if bhdata['ce'] > 1e-15:
+                        bertotti = True
+
+                    if bhdata["ch"] > 1e-15 and bhdata['ce'] < 1e-15:
+                        jordan = True
+
+                else:
+                    jordan = True
+
+                #if (conditions for modified steinmetz):
+                #   modified_steinmetz = True
+
+            if jordan:
+                self.losscalc = 'jordan'
+                logger.info("calculating based on jordan...")
+                for i in f:
+                    pfe.append(lc.pfe_jordan(i, np.array(B), bhdata['ch'], bhdata['ch_freq'], bhdata['cw'],
+                                          bhdata['cw_freq'], bhdata['b_coeff'], 50, 1.5))
+
+            elif bertotti:
+                self.losscalc = 'bertotti'
+                logger.info("calculating based on bertotti")
+                for i in f:
+                    pfe.append(lc.wbert(i, np.array(B), bhdata['ch'], bhdata['cw'], bhdata['ce']))
+
+            elif modified_steinmetz:
+                self.losscalc = 'modified steinmetz'
+                logger.info("calculating based on modified steinmetz...")
+                for i in f:
+                    pfe.append(lc.pfe_modified_steinmetz(i, np.array(B), bhdata['ch'], bhdata['cw'], bhdata['b_coeff'], bhdata['b_beta_coeff'], 1, 1))
+
+            else: # steinmetz
+                self.losscalc = 'steinmetz'
+                logger.info("calculating based on steinmetz...")
+                for i in f:
+                    pfe.append(lc.pfe_steinmetz(i, np.array(B), bhdata['cw'],
+                                            bhdata['cw_freq'], bhdata['b_coeff'], 50, 1.5))
+            bhdata['losses']['pfe'] = pfe
+            bhdata['losses']['B'] = B
+            bhdata['losses']['f'] = f
+
+        idx = 0
+        for i, j in enumerate(bhdata['losses']['f']):
+            if j == 0:
+                idx = i
+                break
+        idx = idx - 1
+        z = lc.fitsteinmetz(bhdata['losses']['f'][0:idx],
+                                     bhdata['losses']['B'],
+                                     bhdata['losses']['pfe'][0:idx],
+                                     1.5,
+                                     50)
+
+        for i, j in enumerate(self.steinmetz):
+            self.steinmetz[j] = z[i]
+        self.steinmetz.update({"Bo": 1.5, "fo": 50})
+
+        z = lc.fitjordan(bhdata['losses']['f'][0:idx],
+                    bhdata['losses']['B'],
+                    bhdata['losses']['pfe'][0:idx],
+                    1.5,
+                    50)
+
+        for i, j in enumerate(self.jordan):
+            self.jordan[j] = z[i]
+        self.jordan.update({"Bo": 1.5, "fo": 50})
+
+        z = lc.fit_bertotti(bhdata['losses']['f'][0:idx],
+                        bhdata['losses']['B'],
+                        bhdata['losses']['pfe'][0:idx])
+
+        for i, j in enumerate(self.bertotti):
+            self.bertotti[j] = z[i]
+        self.bertotti.update({"Bo": 1, "fo": 1, "alpha": 2.0, "ch_freq": 1.0, "cw_freq": 2.0, "b_coeff": 2.0})
+
+        z = lc.fit_modified_steinmetz(bhdata['losses']['f'][0:idx],
+                        bhdata['losses']['B'],
+                        bhdata['losses']['pfe'][0:idx], 1, 1)
+
+        for i,j in enumerate(self.steinmetz_modified):
+            self.steinmetz_modified[j] = z[i]
+        self.steinmetz_modified.update({"Bo": 1, "fo": 1})
+
+        bhdata['losses']['pfe'] = np.transpose(bhdata['losses']['pfe']).tolist() #len(B) rows and len(f) columns
+
+
 def read(filename):
     """read MC/MCV file and return mc dict"""
     mcv = Reader()

femagtools/nc.py

@@ -192,21 +192,23 @@ class Reader(object):
                  for k in ('sr_key', 'nxt_sr_pntr')]
         except:
             pass
-        try:
-            grp = ds.groups['machine']
+
+        grp = ds.groups['machine']
+        if 'speed' in grp.variables:
             self.speed = float(grp.variables['speed'].getValue().data)
+        if 'fc_radius' in grp.variables:
             self.FC_RADIUS = float(grp.variables['fc_radius'].getValue().data)
-            self.pole_pairs = int(grp.variables['pole_pairs'].getValue().data)
+        self.delta_node_angle = float(  # rad
+            grp.variables['delta_node_angle'].getValue().data)
+        self.arm_length = float(grp.variables['arm_length'].getValue().data)
+        for attr in ('pole_pairs', 'poles_sim', 'coil_span',
+                     'state_of_problem', 'move_action'):
+            if attr in grp.variables:
+                setattr(self, attr, int(grp.variables[attr].getValue().data))
+        if 'num_layers' in grp.variables:
             self.layers = int(grp.variables['num_layers'].getValue().data)
-            self.coil_span = int(grp.variables['coil_span'].getValue().data)
-            self.delta_node_angle = float(  # rad
-                grp.variables['delta_node_angle'].getValue().data)
-            self.poles_sim = int(grp.variables['poles_sim'].getValue().data)
+        if 'num_slots' in grp.variables:
             self.slots = int(grp.variables['num_slots'].getValue().data)
-            self.arm_length = float(grp.variables['arm_length'].getValue().data)
-            self.state_of_problem = int(grp.variables['state_of_problem'].getValue().data)
-        except:
-            pass
 
         if hasattr(self, 'state_of_problem'):
             if self.state_of_problem == 5:
@@ -236,18 +238,18 @@ class Reader(object):
         except KeyError:
             pass
 
-        try:
+        if 'el_induction' in ds.groups:
             grp = ds.groups['el_induction']
             (self.pos_el_fe_induction,
              self.el_fe_induction_1,
              self.el_fe_induction_2,
-             self.eddy_cu_vpot) = [grp.variables[k][:]
+             self.eddy_cu_vpot) = [grp.variables[k][:] if k in grp.variables else []
                                    for k in ('position',
                                              'fe_induction_1',
                                              'fe_induction_2',
                                              'eddy_cu_vpot')]
             logger.debug('el_fe_induction %d', len(self.pos_el_fe_induction))
-        except KeyError:
+        else:
             self.pos_el_fe_induction = []
             self.el_fe_induction_1 = []
             self.el_fe_induction_2 = []

femagtools/parstudy.py

@@ -6,6 +6,7 @@ import scipy as sc
 import logging
 import glob
 import os
+import re
 import time
 import shutil
 import functools
@@ -172,7 +173,8 @@ class ParameterStudy(object):
         else:
             workdir = pathlib.Path(self.femag.workdir)
         for d in workdir.glob('[0-9]*'):
-            shutil.rmtree(d)
+            if re.search(r'^\d+$', d.name):
+                shutil.rmtree(d)
 
         extra_result_files = []
         if simulation.get('airgap_induc', False):

femagtools/plot/bch.py

@@ -515,80 +515,151 @@ def cogging(bch, title=''):
         fig.subplots_adjust(top=0.92)
 
 
-def transientsc(bch, title=''):
-    """creates a transient short circuit plot"""
-    cols = 1
-    rows = 2
-    htitle = 1.5 if title else 0
-    fig, ax = plt.subplots(nrows=rows, ncols=cols,
-                           figsize=(10, 3*rows + htitle))
-    if title:
-        fig.suptitle(title, fontsize=16)
-
-    row = 1
-    plt.subplot(rows, cols, row)
-    ax = plt.gca()
+def demagnetization(demag, ax=0):
+    """plot rel. remanence vs. current"""
+    if ax == 0:
+        ax = plt.gca()
+    scale = 1
+    unit = 'A'
+    if np.max(demag['i1']) > 25e3:
+        scale = 1e-3
+        unit = 'kA'
+    i1 = [scale*x for x in demag['i1']]
+    ax.plot(i1, demag['rr'], 'o', color='C0')
+    ax.plot(i1, demag['rr'], color='C0')
+    rrmin = 0.6
+    if demag.get('i1c', 0):
+        Icrit = scale*demag['i1c']
+        Hk = demag['Hk']
+        Tmag = demag['Tmag']
+        di = 0.05*np.max(i1)
+        rrmin = min(0.6, np.min(demag['rr']))
+        ax.plot([Icrit, Icrit], [rrmin, 1], 'k--')
+        ax.annotate(
+            f'Icrit = {Icrit:.1f}{unit}\nHk = {Hk:.1f} kA/m\nTmag={Tmag:.1f} °C',
+            xy=(Icrit, rrmin),
+            xytext=(Icrit-di, rrmin+0.1*(1-rrmin)), ha='right',
+            bbox={'facecolor': 'white',
+                  'edgecolor': 'white'})
+    ax.set_ylim([rrmin, 1.01])
+    ax.set_ylabel('Rel. Remanence')
+    ax.set_xlabel(f'Phase Current / {unit}')
+    ax.grid()
+
+
+def transientsc_currents(scData, ax=0, title='', set_xlabel=True):
+    """plot transient shortcircuit currents vs time"""
+    if ax == 0:
+        ax = plt.gca()
     ax.grid(True)
-    istat = np.array([bch.scData[i]
+    if title:
+        ax.set_title(title)
+    istat = np.array([scData[i]
                       for i in ('ia', 'ib', 'ic')])
     pv = [find_peaks_and_valleys(
-        np.array(bch.scData['time']), i1)
+        np.array(scData['time']), i1)
           for i1 in istat]
     try:
         ipvmax = np.argmax(
             [y['yp'] if np.abs(y['yp']) > np.abs(y['yv']) else y['yv']
-             for y in pv])
+             for y in pv if y['yp']])
         imax = pv[ipvmax]['yp'] if np.abs(pv[ipvmax]['yp']) > np.abs(pv[ipvmax]['yv']) else pv[ipvmax]['yv']
+        iac = [pv[ipvmax]['tpeaks'][-1], pv[ipvmax]['peaks'][-1]]
     except KeyError:
         pass
     if np.max(istat) > 4000:
         istat *= 1e-3
-        imax *= 1e-3
-        ax.set_title('Currents / kA')
+        try:
+            imax *= 1e-3
+            iac[1] *= 1e-3
+        except NameError:
+            pass
+        ax.set_ylabel('Currents / kA')
     else:
-        ax.set_title('Currents / A')
+        ax.set_ylabel('Currents / A')
 
     for i, iph in zip(('ia', 'ib', 'ic'), istat):
-        ax.plot(bch.scData['time'], iph, label=i)
+        ax.plot(scData['time'], iph, label=i)
     try:
         ax.plot([pv[ipvmax]['tp']], [imax], '.')
+        ax.plot([iac[0]], [iac[1]], '.')
+        dtx = (scData['time'][-1]-scData['time'][0])/75
+        dy = imax/25
         ax.annotate(f'Imax = {imax:.1f}',
                     xy=(pv[ipvmax]['tp'], imax),
-                    xytext=(pv[ipvmax]['tp']+0.01, imax))
+                    xytext=(pv[ipvmax]['tp']+dtx, imax-dy))
+        dy = iac[1]/25
+        ax.annotate(f'I = {iac[1]:.1f}',
+                    xy=iac,
+                    xytext=(iac[0]+dtx, iac[1]-dy))
     except NameError:
         pass
-    ax.set_xlabel('Time / s')
+    if set_xlabel:
+        ax.set_xlabel('Time / s')
     ax.legend()
 
-    row = 2
-    plt.subplot(rows, cols, row)
-    ax = plt.gca()
+
+def transientsc_torque(scData, ax=0, title='', set_xlabel=True):
+    """plot transient shortcircuit torque vs time"""
+    if ax == 0:
+        ax = plt.gca()
+    if title:
+        ax.set_title(title)
     pv = find_peaks_and_valleys(
-        np.array(bch.scData['time']), np.array(bch.scData['torque']))
+        np.array(scData['time']), np.array(scData['torque']))
     try:
         tqmax = pv['yp'] if np.abs(pv['yp']) > np.abs(pv['yv']) else pv['yv']
         tp = pv['tp'] if np.abs(pv['yp']) > np.abs(pv['yv']) else pv['tv']
-    except KeyError:
+        tc = [pv['tpeaks'][-1], pv['peaks'][-1]]
+    except (KeyError, ValueError):
         pass
-    torque = np.array(bch.scData['torque'])
+    torque = np.array(scData['torque'])
     if np.max(torque) > 4000:
         torque *= 1e-3
-        tqmax *= 1e-3
-        ax.set_title('Torque / kNm')
+        try:
+            tqmax *= 1e-3
+            tc[1] *= 1e-3
+        except NameError:
+            pass
+        ax.set_ylabel('Torque / kNm')
     else:
-        ax.set_title('Torque / Nm')
+        ax.set_ylabel('Torque / Nm')
 
     ax.grid(True)
-    ax.plot(bch.scData['time'], torque)
+    ax.plot(scData['time'], torque)
     try:
         ax.plot([tp], [tqmax], '.')
+        ax.plot([tc[0]], [tc[1]], '.')
+        dtx = (scData['time'][-1]-scData['time'][0])/75
+        dy = tqmax/25
         ax.annotate(f'Tmax = {tqmax:.1f}',
                     xy=(tp, tqmax),
-                    xytext=(tp+0.01, tqmax))
+                    xytext=(tp+dtx, tqmax-dy))
+        dy = tc[1]/25
+        ax.annotate(f'T = {tc[1]:.1f}',
+                    xy=tc,
+                    xytext=(tc[0]+dtx, tc[1]))
     except NameError:
         pass
-    ax.set_xlabel('Time / s')
+    if set_xlabel:
+        ax.set_xlabel('Time / s')
+
+def transientsc(bch, title=''):
+    """creates a transient short circuit plot"""
+    try:
+        scData = bch.scData
+    except AttributeError:
+        scData = bch
+    cols = 1
+    rows = 2
+    htitle = 1.5 if title else 0
+    fig, axs = plt.subplots(nrows=rows, ncols=cols, sharex=True,
+                            figsize=(10, 3*rows + htitle))
+    if title:
+        fig.suptitle(title, fontsize=16)
 
+    transientsc_currents(scData, axs[0], set_xlabel=False)
+    transientsc_torque(scData, axs[1])
     fig.tight_layout(h_pad=2)
     if title:
         fig.subplots_adjust(top=0.92)
@@ -602,24 +673,35 @@ def transientsc_demag(demag, magnet=0, title='', ax=0):
     """
     if ax == 0:
         ax = plt.gca()
-    pos = [d['displ'] for d in demag if 'displ' in d]
-    hmax = [-d['H_max'] for d in demag if 'H_max' in d]
-    havg = [-d['H_av'] for d in demag if 'H_av' in d]
-    hclim = [-d['lim_hc'] for d in demag if 'lim_hc' in d]*2
-
+    if type(d) == list:
+        pos = [d['displ'] for d in demag if 'displ' in d]
+        hmax = [-d['H_max'] for d in demag if 'H_max' in d]
+        havg = [-d['H_av'] for d in demag if 'H_av' in d]
+        hclim = [-d['lim_hc'] for d in demag if 'lim_hc' in d][0]
+    else:
+        pos = demag['displ']
+        hmax = demag['H_max']
+        havg = demag['H_av']
+        hclim = demag['Hk']
     ax.set_title('Transient Short Circuit Demagnetization [kA/m]')
     ax.plot(pos, hmax,
             label='H Max {:4.2f} kA/m'.format(max(hmax)))
     ax.plot(pos, havg,
             label='H Avg {:4.2f} kA/m'.format(max(havg)))
     if len(hclim) > 1:
-        ax.plot([pos[0], pos[-1]], hclim, color='C3', linestyle='dashed',
-                label='Hc {:4.2f} kA/m'.format(hclim[0]))
-
+        ax.plot([pos[0], pos[-1]], [hclim,hclim], color='C3',
+                linestyle='dashed',
+                label='Hc {:4.2f} kA/m'.format(hclim))
+    if 'Tmag' in demag:
+        Tmag = demag['Tmag']
+    elif magnet:
+        Tmag = magnet['Tmag']
+    else:
+        Tmag = ''
     ax.set_xlabel('Rotor Position / °')
     ax.grid(True)
-    if magnet:
-        ax.legend(title=f"Magnet Temperature {magnet['Tmag']}°C")
+    if Tmag:
+        ax.legend(title=f"Magnet Temperature {Tmag}°C")
     else:
         ax.legend()
 

femagtools/plot/nc.py

@@ -130,6 +130,19 @@ def demag(isa, cmap=DEFAULT_CMAP, ax=0):
     logger.info("Max demagnetization %f", np.max(demag))
 
 
+def remanence(isa, cmap=DEFAULT_CMAP, ax=0):
+    """plot remanence of NC/I7/ISA7 model
+    Args:
+      isa: Isa7/NC object
+    """
+    emag = [e for e in isa.elements if e.is_magnet()]
+    rem = np.linalg.norm([e.remanence(isa.MAGN_TEMPERATURE)
+                          for e in emag], axis=1)
+    _contour(ax, f'Remanence at {isa.MAGN_TEMPERATURE} °C (min {np.min(rem):.1f} T)',
+             emag, rem, 'T', cmap, isa)
+    logger.info("Min remanence %f", np.min(rem))
+
+
 def demag_pos(isa, pos=-1, icur=-1, ibeta=-1, cmap=DEFAULT_CMAP, ax=0):
     """plot demag of NC/I7/ISA7 model at rotor position
     Args: