femagtools 1.7.8__py3-none-any.whl → 1.8.0__py3-none-any.whl

femagtools/mcv.py

@@ -103,6 +103,54 @@ def norm_pfe(B, pfe):
                   for x in Bv[:n]] + [None]*(len(Bv)-n))
     return Bv.tolist(), m
 
+def extrapol(crv, jsat=0, bmax=3):
+    """extends BH curve into saturation range"""
+    curve = copy.deepcopy(crv)
+    dh = curve['hi'][-1]-curve['hi'][-2]
+    db = curve['bi'][-1]-curve['bi'][-2]
+    mue_d = db/dh
+    mue = curve['bi'][-1]/curve['hi'][-1]
+    db = 3e-2*curve['bi'][-1]
+    b2 = 1.5
+
+    curve['muer'] = [b/MUE0/h if h>0 else float('nan')
+                     for b, h in zip(curve['bi'],
+                                     curve['hi'])]
+
+    # extend bh-curve into saturation
+    while mue_d > 1.01*MUE0 and mue > 1.5*MUE0:
+        mue_d = MUE0 + (mue_d-MUE0)/np.sqrt(b2)
+        curve['bi'].append(curve['bi'][-1]+db)
+        curve['hi'].append(curve['hi'][-1]+db/mue_d)
+        curve['muer'].append(curve['bi'][-1]/MUE0/curve['hi'][-1])
+        b2 += 2
+        mue = curve['bi'][-1]/curve['hi'][-1]
+
+    # Fröhlich-Kennelly coefficients
+    if jsat:
+        hx = curve['hi'][-1]
+        bx = curve['bi'][-1]
+        fkb = 1./jsat
+        fka = (hx/(bx - MUE0*hx) - hx/jsat)
+    else:
+        Js1 = curve['bi'][-1] - MUE0*curve['hi'][-1]
+        Js0 = curve['bi'][-2] - MUE0*curve['hi'][-2]
+        fkb = ((curve['hi'][-1]/Js1 - curve['hi'][-2]/Js0)
+               /(curve['hi'][-1] - curve['hi'][-2]))
+        fka = curve['hi'][-1]/Js1 - fkb*curve['hi'][-1]
+    logger.debug("B values %d Fröhlich-Kennelly coeffs: a %f b %f",
+                 len(curve['bi']), fka, fkb)
+    bstep = 0.15
+    bx = np.arange(curve['bi'][-1] + bstep, bmax, bstep)
+    # Fröhlich-Kennelly approximation
+    b = fkb * bx - MUE0*fka - 1
+    a = fkb * bx
+    c = MUE0*fka
+    nuer = (b + np.sqrt(b*b + 4*a*c))/2/a
+    curve['bi'] += bx.tolist()
+    curve['hi'] += (nuer*bx/MUE0).tolist()
+    return curve
+
 
 def recalc_bsin(curve):
     """recalculates B-H curve (static problems) into effective
@@ -159,7 +207,7 @@ def recalc_hsin(curve):
     return ncurve
 
 
-def approx(db2, curve):
+def approx(db2, curve, ctype):
     """return nuer, bi2, a, b approx for curve"""
     nuek0 = (curve['hi'][1] - curve['hi'][0]) / \
             (curve['bi'][1]-curve['bi'][0])
@@ -191,12 +239,22 @@ def approx(db2, curve):
         nuer.append(MUE0*nuek1)
         bi2.append(bk12)
 
-    a.append(1.0)
-    b.append(MUE0*curve['hi'][-1]-curve['bi'][-1])
+    if ctype in (DEMCRV, MAG_AC_CRV):
+        dhdbn = 0
+        k = len(bi2)-1
+        if curve['bi'][k] - curve['bi'][k-1] > 0:
+            dhdbn = ((curve['hi'][k] - curve['h'][k-1],KK)
+                     /(curve['bi'][k] - curve['bi'][k-1]))
+        a.append(MUE0*dhdbn)
+        b.append(MUE0*curve['hi'][k] - dhdbn*curve['bi'][k])
+    else:
+        a.append(1.0)
+        b.append(MUE0*curve['hi'][-1]-curve['bi'][-1])
     return dict(nuer=nuer, a=a, b=b, bi2=bi2)
 
 
 def fe_sat_mag(curve):
+    """returns maximum polarization of all BH curves"""
     fesat = 0
     for c in curve:
         js2 = c['bi'][-1] - MUE0*c['hi'][-1]
@@ -219,7 +277,7 @@ def findNotNone(l):
 
 
 class Mcv(object):
-    def __init__(self):
+    def __init__(self, data={}):
         # default values from file: mcv.par
         self.ACT_VERSION_MC_CURVE = 0
         self.ORIENTED_VERSION_MC_CURVE = 1
@@ -248,7 +306,6 @@ class Mcv(object):
         self.mc1_induction_factor = self.MC1_INDUCTION_FACTOR
         self.mc1_induction_beta_factor = self.MC1_INDUCTION_BETA_FACTOR
         self.mc1_fe_spez_weigth = self.MC1_FE_SPEZ_WEIGTH
-        self.mc1_fe_sat_magnetization = self.MC1_FE_SAT_MAGNETIZATION
 
         self.mc1_title = ''
         self.version_mc_curve = self.ACT_VERSION_MC_CURVE
@@ -274,26 +331,18 @@ class Mcv(object):
 
         self.mc1_energy = [[0]*self.MCURVES_MAX]*self.MC1_NIMAX
 
-    def rtrimValueList(self, vlist):
-        """cut list at first 0"""
-        le = len(vlist)
-        for i in range(le-1, -1, -1):
-            if vlist[i] != 0.:
-                break
-        return list(vlist[:i+1])
-
-    def __getitem__(self, key):
-        if key == 'ctype':  # for compatibility purposes
-            return self.mc1_type
-        return getattr(self, key)
-
-
-class Writer(Mcv):
-    def __init__(self, data=None):
-        Mcv.__init__(self)
         if data:
             self.setData(data)
 
+            self.mc1_curves = len(self.curve)
+            if self.mc1_type == MAGCRV and self.mc1_curves > 1:
+                self.mc1_type = ORIENT_CRV
+            if self.mc1_type in (ORIENT_CRV, ORIENT_PM_CRV):
+                self.version_mc_curve = self.ORIENTED_VERSION_MC_CURVE
+            elif self.mc1_type == DEMCRV_BR:
+                self.version_mc_curve = self.PARAMETER_PM_CURVE
+
+
     def __setattr__(self, key, val):
         try:
             self.__dict__[key] = val
@@ -317,6 +366,24 @@ class Writer(Mcv):
             pass
         return
 
+    def rtrimValueList(self, vlist):
+        """cut list at first 0"""
+        le = len(vlist)
+        for i in range(le-1, -1, -1):
+            if vlist[i] != 0.:
+                break
+        return list(vlist[:i+1])
+
+    def __getitem__(self, key):
+        if key == 'ctype':  # for compatibility purposes
+            return self.mc1_type
+        return getattr(self, key)
+
+
+class Writer(Mcv):
+    def __init__(self, data=None):
+        Mcv.__init__(self, data)
+
     def getBlockLength(self, d):
         if isinstance(d, string_types) or isinstance(d, bytes):
             try:
@@ -374,11 +441,6 @@ class Writer(Mcv):
 
     def _prepare(self, fillfac, recsin):
         """prepare output format (internal use only)"""
-        if self.mc1_type in (ORIENT_CRV, ORIENT_PM_CRV):
-            self.version_mc_curve = self.ORIENTED_VERSION_MC_CURVE
-        elif self.mc1_type == DEMCRV_BR:
-            self.version_mc_curve = self.PARAMETER_PM_CURVE
-
         curve = copy.deepcopy(self.curve)
         if fillfac:
             alpha = fillfac/self.mc1_fillfac
@@ -392,17 +454,17 @@ class Writer(Mcv):
         if fillfac or recsin:
             if hasattr(self, 'mc1_fe_sat_magnetization'):
                 self.mc1_fe_sat_magnetization = fe_sat_mag(curve)
-        logger.info("%s Type: %d Num Curves %d",
+        logger.info("%s Type: %d (%s) Num Curves %d",
                     self.name, self.version_mc_curve,
+                    types[self.mc1_type],
                     len(self.curve))
-        self.mc1_curves = len(self.curve)
         self.mc1_ni = [min(len(c['hi']),
                            len(c['bi']))
                        for c in self.curve if 'hi' in c]
         self.mc1_db2 = [(c['bi'][-1]**2 - c['bi'][0]**2)/n
                         for c, n in zip(curve, self.mc1_mi)]
         for db2, c in zip(self.mc1_db2, curve):
-            c.update(approx(db2, c))
+            c.update(approx(db2, c, self.mc1_type))
         if not hasattr(self, 'mc1_fe_sat_magnetization'):
             self.mc1_fe_sat_magnetization = fe_sat_mag(curve)
         self.mc1_mi = [len(c['a'])
@@ -513,6 +575,7 @@ class Writer(Mcv):
                 self.mc1_cw_factor = cw
                 self.mc1_cw_freq_factor = beta
                 self.mc1_induction_factor = gamma
+
         except AttributeError:
             pass
         self.writeBlock([float(self.mc1_base_frequency),
@@ -528,10 +591,10 @@ class Writer(Mcv):
         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), 
+            try:
+                self.writeBlock([float(self.mc1_ce_factor),
                                  float(self.mc1_induction_beta_factor)])
-            except: 
+            except:
                 pass
             return
 
@@ -599,7 +662,7 @@ class Writer(Mcv):
             logger.info('Losses n freq %d n ind %d', nfreq, nind)
         except Exception as e:
             logger.error("Exception %s", e, exc_info=True)
-        
+
     def writeMcv(self, filename, fillfac=None, recsin=''):
         # windows needs this strip to remove '\r'
         filename = filename.strip()
@@ -612,7 +675,7 @@ class Writer(Mcv):
         else:
             binary = False
             self.fp = open(filename, "wb")
-        logger.info("Write File %s, binary format %d", filename, binary)
+        logger.info("Write File %s, binary format", filename)
 
         self.writeBinaryFile(fillfac, recsin)
         self.fp.close()
@@ -737,8 +800,9 @@ class Reader(Mcv):
             if self.version_mc_curve == self.ORIENTED_VERSION_MC_CURVE or \
                self.version_mc_curve == self.PARAMETER_PM_CURVE:
                 self.mc1_curves = int(line[4])
-        logger.debug("MC file %s Version %s Curves %d",
-                     filename, self.version_mc_curve, self.mc1_curves)
+        logger.info("Read file %s %s Type: %d (%s) Num Curves %d",
+                    filename, self.name, self.version_mc_curve,
+                    types[self.mc1_type], self.mc1_curves)
         if self.mc1_type == DEMCRV_BR:
             self.mc1_angle[self.mc1_curves-1] = self.mc1_remz
 
@@ -873,7 +937,7 @@ class Reader(Mcv):
 
         self.ce = 0
         self.b_beta_coeff = 0
-        try: 
+        try:
             if not self.losses['f'][0]:
                 self.fp.seek(-16, 1)
             res = self.readBlock([float]*2)
@@ -882,30 +946,33 @@ class Reader(Mcv):
             pass
 
     def get_results(self):
+        self.desc = self.mc1_title
+        self.fillfac = self.mc1_fillfac
+        #self.cversion = self.version_mc_curve
         result = {
-            'name': self.name,
-            'desc': self.mc1_title,
-            'cversion': self.version_mc_curve,
-            'ctype': self.mc1_type,
-            'recalc': self.mc1_recalc,
-            'remz': self.mc1_remz,
-            'bsat': self.mc1_bsat,
-            'bref': self.mc1_bref,
-            'fillfac': self.mc1_fillfac,
-            'fo': self.fo,
-            'Bo': self.Bo,
-            'ch': self.ch,
-            'ch_freq': self.ch_freq,
-            'cw': self.cw,
-            'ce': self.ce,
-            'b_beta_coeff': self.b_beta_coeff,
-            'cw_freq': self.cw_freq,
-            'b_coeff': self.b_coeff,
-            'rho': self.rho,
-            'fe_sat_mag': self.fe_sat_mag,
-            'curve': [{k: c[k] for k in ('hi', 'bi')}
-                      for c in self.curve]
-        }
+            k: getattr(self, k) for k in (
+                'name',
+                'desc',
+                'cversion',
+                'ctype',
+                'recalc',
+                'remz',
+                'bsat',
+                'bref',
+                'fillfac',
+                'fo',
+                'Bo',
+                'ch',
+                'ch_freq',
+                'cw',
+                'ce',
+                'b_beta_coeff',
+                'cw_freq',
+                'b_coeff',
+                'rho',
+                'fe_sat_mag') if hasattr(self, k)}
+        result['curve'] = [{k: c[k] for k in ('hi', 'bi')}
+                           for c in self.curve]
         try:
             if self.losses:
                 result['losses'] = self.losses
@@ -1003,69 +1070,6 @@ class MagnetizingCurve(object):
             pass
         return None
 
-    def recalc(self):
-        for m in self.mcv:
-            curve = self.mcv[m]['curve'][0]
-            mi = MC1_MIMAX-2
-            dh = curve['hi'][-1]-curve['hi'][-2]
-            db = curve['bi'][-1]-curve['bi'][-2]
-            dmue_d = db/dh
-            dmue = curve['bi'][-1]/curve['hi'][-1]
-            db = 3e-2*curve['bi'][-1]
-            n3 = 1.5
-
-            curve['muer'] = [b/MUE0/h
-                             for b, h in zip(curve['bi'],
-                                             curve['hi'])]
-
-            # extend bh-curve into saturation
-            while dmue_d > 1.01*MUE0 and dmue > 1.5*MUE0:
-                dmue_d = MUE0 + (dmue_d-MUE0)/np.sqrt(n3)
-                curve['bi'].append(curve['bi'][-1]+db)
-                curve['hi'].append(curve['hi'][-1]+db/dmue_d)
-                curve['muer'].append(curve['bi'][-1]/MUE0/curve['hi'][-1])
-                n3 += 0.2
-                dmue = curve['bi'][-1]/curve['hi'][-1]
-
-            self.mcv[m]['db2'] = (curve['bi'][-1]**2 -
-                                  curve['bi'][0]**2)/(mi-1)
-            nuek0 = (curve['hi'][1] - curve['hi'][0]) / \
-                    (curve['bi'][1]-curve['bi'][0])
-            for j1 in range(len(curve['bi'])):
-                bk02 = curve['bi'][j1]**2
-                if bk02 > 0:
-                    break
-            curve['nuer'] = [MUE0*nuek0]
-            curve['bi2'] = [bk02]
-            curve['a'] = []
-            curve['b'] = []
-
-            bk1 = 0.0
-            while bk1 <= curve['bi'][-1]:
-                bk12 = bk02 + self.mcv[m]['db2']
-                bk1 = np.sqrt(bk12)
-                j = 2
-                while j < len(curve['bi']) and bk1 <= curve['bi'][j]:
-                    j += 1
-                j -= 1
-                bdel = curve['bi'][j] - curve['bi'][j1]
-                c1 = (curve['hi'][j] - curve['hi'][j1])/bdel
-                c2 = curve['hi'][j1] - c1*curve['bi'][j1]
-
-                nuek1 = c1 + c2/bk1
-
-                curve['a'].append(MUE0*(bk12*nuek0 -
-                                        bk02*nuek1)/self.mcv[m]['db2'])
-                curve['b'].append(MUE0*(nuek1 - nuek0)/self.mcv[m]['db2'])
-                nuek0 = nuek1
-                bk02 = bk12
-
-                curve['nuer'].append(MUE0*nuek1)
-                curve['bi2'].append(bk12)
-
-            curve['a'].append(1.0)
-            curve['b'].append(MUE0*curve['hi'][-1]-curve['bi'][-1])
-
     def fix_name(self, name, fillfac=1.0):
         """return os compatible mcv name including fillfac"""
         if not self.find_by_name(name):

femagtools/me.py

@@ -3,8 +3,8 @@ Postprocessing FEMAG-ME results
 """
 __author__ = 'dapu zhang'
 
-import re 
-import numpy as np 
+import re
+import numpy as np
 import matplotlib.pyplot as plt
 import logging
 
@@ -16,33 +16,33 @@ def get_eigenvectors(filelist, psfiles):
     eigenvecs = {}
     eigenfreq = []
     ps_data = []
-    temp = [] 
+    temp = []
     temp_arr = []
     read_fig = False
 
     if len(psfiles) > 0: read_fig = True
     if len(filelist) == 0: return []
-    
-    for k, kk in zip(filelist, range(len(filelist))): 
+
+    for k, kk in zip(filelist, range(len(filelist))):
         # read ps file
         if read_fig: ps_data.append(plt.imread(psfiles[kk]))
         eigenvecs[str(kk)] = {}
-        with open(k, 'r') as f: 
+        with open(k, 'r') as f:
             data = f.read().split('\n')
-        eigenval = float(re.split('\s+', data[0].strip())[2])
+        eigenval = float(re.split(r'\s+', data[0].strip())[2])
         eigenfreq.append(eigenval/2/np.pi)
-        
-        for i in range(len(data[1:-1])): 
-            for j in data[2+i].strip().split(' '): 
+
+        for i in range(len(data[1:-1])):
+            for j in data[2+i].strip().split(' '):
                 if j != '':
                     temp.append(float(j))
 
         temp_arr = np.array(temp).reshape(-1, 5)
         idx_collect = []
         # remove the index, at which the dof equals zero
-        for c in range(temp_arr.shape[0]): 
+        for c in range(temp_arr.shape[0]):
             if np.abs(temp_arr[c, 1]) < 1e-15 and \
-            np.abs(temp_arr[c, 2]) < 1e-15: 
+            np.abs(temp_arr[c, 2]) < 1e-15:
                 idx_collect.append(c)
         # prepare the data from the further calculation
         temp_arr = np.delete(temp_arr, np.array(idx_collect), axis=0)
@@ -52,4 +52,4 @@ def get_eigenvectors(filelist, psfiles):
         # return node position
         if kk == 0: eigenvecs.update({'node_pos': temp_arr[:, 4::]})
 
-    return [ps_data, eigenfreq, eigenvecs] 
+    return [ps_data, eigenfreq, eigenvecs]

femagtools/model.py

@@ -386,6 +386,13 @@ class MachineModel(Model):
                 if mcv:
                     logger.debug('shaft mcv %s', mcv)
                     rotor['mcvkey_shaft'] = magcurves.fix_name(mcv)
+                    mshaft = magcurves.find_by_name(mcv)
+                    thkeys_shaft = ['thcond', 'thcap', 'rho']
+                    if mshaft and set(thkeys_shaft).issubset(mshaft.keys()):
+                        for k in thkeys_shaft:
+                            rotor[k+'_shaft'] = mshaft[k]
+                        rotor['spmaweight_shaft'] = rotor['rho_shaft']
+
                     self.stator['mcvkey_shaft_name'] = mcv
                     names.append((mcv, 1.0))
                 else:
@@ -435,7 +442,7 @@ class MachineModel(Model):
 
     def is_complete(self):
         """check completeness of models"""
-        if self.is_dxffile():
+        if self.is_dxffile() or self.is_svgfile():
             return True
         try:
             self.statortype()
@@ -453,6 +460,12 @@ class MachineModel(Model):
                 return True
         return False
 
+    def is_svgfile(self):
+        if 'svgfile' in self.__dict__:
+            if isinstance(self.svgfile, dict):
+                return True
+        return False
+
     def has_magnet(self):  # either rotor or magnet
         return hasattr(self, 'magnet')
 

femagtools/moo/population.py

@@ -198,21 +198,23 @@ class Population:
         self.update_pareto_information()
         retval = [[] for s in range(max(self.pareto_rank)+1)]
         for i, j in enumerate(self.individuals):
-            retval[self.pareto_rank[i]].append(i)
+            retval[self.pareto_rank[i]].append(j)
         return retval
 
     def compute_ideal(self):
-        return [min(x)
+        return [np.min(np.array(x)[np.isfinite(x)])
                 for x in zip(*[i.cur_f
-                               for i in self.individuals if i.rank == 0])]
+                               for i in self.individuals
+                               if i.rank == 0])]
 
     def compute_nadir(self):
-        return [max(x)
+        return [np.max(np.array(x)[np.isfinite(x)])
                 for x in zip(*[i.cur_f
-                               for i in self.individuals if i.rank == 0])]
+                               for i in self.individuals
+                               if i.rank == 0])]
 
     def compute_worst(self):
-        return [max(x)
+        return [np.max(np.array(x)[np.isfinite(x)])
                 for x in zip(*[i.cur_f
                                for i in self.individuals])]
 
@@ -252,7 +254,7 @@ class Population:
             raise ValueError(
                 'Invalid components of the objective function selected for plot')
 
-        p_dim = self.problem.f_dimension
+        p_dim = self.problem.f_dim
 
         if p_dim == 1:
             raise ValueError(

femagtools/nc.py

@@ -23,6 +23,7 @@ class Reader(object):
 
     def __init__(self, filename):
         ds = netCDF4.Dataset(filename)
+        node_temperature = None
         self.POINT_ISA_POINT_REC_PT_CO_X = []
         self.POINT_ISA_POINT_REC_PT_CO_Y = []
         self.LINE_ISA_LINE_REC_LN_PNT_1 = []
@@ -54,6 +55,11 @@ class Reader(object):
              grp.variables[k][:-1]
              for k in ('bnd_cnd', 'bnd_cnd', 'per_nod',
                        'co_1', 'co_2', 'co_rad', 'co_phi', 'vp_re', 'vp_im')]
+        try:
+            node_temperature = grp.variables['temperature'][:-1]
+        except:
+            pass
+
         logger.debug('Nodes: %d', len(self.NODE_ISA_NODE_REC_ND_CO_1))
 
         grp = ds.groups['node_elements']
@@ -198,9 +204,15 @@ class Reader(object):
             self.poles_sim = int(grp.variables['poles_sim'].getValue().data)
             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:
+                # th simulation
+                if node_temperature is not None:
+                    self.NODE_ISA_NODE_REC_ND_VP_IM = node_temperature
         self.MAGN_TEMPERATURE = 20
         self.BR_TEMP_COEF = 0
         try:

femagtools/plot/__init__.py

@@ -16,5 +16,5 @@ from .nc import spel, mesh, demag, demag_pos, \
     airgap_flux_density_pos, loss_density
 from .mcv import mcv_hbj, mcv_muer, felosses
 from .phasor import i1beta_phasor, iqd_phasor, phasor
-from .wdg import mmf, mmf_fft, zoneplan, winding_factors, winding
+from .wdg import mmf, mmf_fft, zoneplan, winding_factors, winding, currdist
 from .fieldlines import fieldlines

femagtools/plot/fieldlines.py

@@ -4,7 +4,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import matplotlib.lines as mpl
 
-rgbpat = re.compile('rgb\((\d+),(\d+),(\d+)\)')
+rgbpat = re.compile(r'rgb\((\d+),(\d+),(\d+)\)')
 
 def fieldlines(svgfilename, ax=0):
     """plot fieldlines from svg file"""

femagtools/plot/mcv.py

@@ -37,10 +37,12 @@ def mcv_hbj(mcv, log=True, ax=0):
             label = 'Flux Density ({0}°)'.format(mcv.mc1_angle[k])
         if log:
             ax.semilogx(hi, bi, label=label)
+            ax.semilogx(hi, bi, 'k.')
             if ji:
                 ax.semilogx(hi, ji, label='Polarisation')
         else:
             ax.plot(hi, bi, label=label)
+            ax.plot(hi, bi, 'k.')
             if ji:
                 ax.plot(hi, ji, label='Polarisation')
     ax.set_xlabel('H / kA/m')
@@ -59,10 +61,26 @@ def mcv_muer(mcv, ax=0):
     if ax == 0:
         ax = plt.gca()
     ax.plot(bi, ur)
+    ax.plot(bi, ur, 'k.')
     ax.set_xlabel('B / T')
     ax.set_title('rel. Permeability')
     ax.grid()
 
+def mcv_nuer(mcv, ax=0):
+    """plot rel. reluctivity vs. B of mcv dict"""
+    MUE0 = 4e-7*np.pi
+    bi, ur = zip(*[(bx, bx/hx/MUE0)
+                   for bx, hx in zip(mcv['curve'][0]['bi'],
+                                     mcv['curve'][0]['hi']) if not hx == 0])
+    if ax == 0:
+        ax = plt.gca()
+    nuer = 1/np.array(ur)
+    ax.plot(bi, 1/np.array(ur))
+    ax.plot(bi, nuer, 'k.')
+    ax.set_xlabel('B / T')
+    ax.set_title('rel. Reluctivity')
+    ax.grid()
+
 
 def felosses(losses, coeffs, title='', log=True, ax=0):
     """plot iron losses with steinmetz or jordan approximation

femagtools/plot/nc.py

@@ -35,19 +35,19 @@ def spel(isa, superelements=[], with_axis=False, ax=0):
                             color=isa.color[se.color], lw=0))
         try:
             # draw wire direction
-            if se.subregion: 
-                if se.subregion.curdir != 0: 
+            if se.subregion:
+                if se.subregion.curdir != 0:
                         wkey = se.subregion.winding.key
-                        if se.subregion.curdir < 0: 
+                        if se.subregion.curdir < 0:
                             label = str(se.subregion.curdir*wkey)
-                        else: 
+                        else:
                             label = '+'+str(se.subregion.curdir*wkey)
 
                         xy = np.array([n.xy
                             for nc in se.nodechains
                             for n in nc.nodes])
                         cx, cy = np.mean(np.unique(xy[:, 0])), np.mean(np.unique(xy[:, -1]))
-                        ax.text(cx, cy, label, rotation=np.arctan2(cy, cx)/np.pi*180-90, 
+                        ax.text(cx, cy, label, rotation=np.arctan2(cy, cx)/np.pi*180-90,
                                 horizontalalignment='center', verticalalignment='center')
         except:
             pass
@@ -296,3 +296,20 @@ def loss_density(isa, subreg=[], cmap=DEFAULT_CMAP, ax=0):
     elements = [e for e in __elements_of_subreg(isa, subreg)]
     lossd = np.array([e.loss_density*1e-3 for e in elements])
     _contour(ax, 'Loss Density kW/m³', elements, lossd, '', cmap)
+
+def temperature_distribution(isa, ax=0, cmap='plasma'):
+    """plot temperature distribution of NC/I7/ISA7 model
+
+    Args:
+        isa: Isa7/NC object
+    """
+    temp = []
+    elements = [e for e in isa.elements]
+    for e in isa.elements:
+        tmp = 0
+        ctr = 1
+        for n in e.vertices:
+            tmp += n.vpot[-1]
+            ctr = ctr + 1
+        temp.append(tmp/ctr)
+    _contour(ax, 'Temperature in K', elements, temp, '', cmap)