femagtools 1.8.5__py3-none-any.whl → 1.8.7__py3-none-any.whl

femagtools/isa7.py

@@ -1418,6 +1418,13 @@ class Element(BaseEntity):
         """return True if the element has lamination properties"""
         return self.reluc != (1.0, 1.0) and self.mag == (0.0, 0.0)
 
+    def remanence(self, temperature=20):
+        """return remanence Brx, Bry at element
+        Arguments:
+          temperature: (float) temperature in °C"""
+        br_temp_corr = 1. + self.br_temp_coef*(temperature - 20.)
+        return self.mag[0]*br_temp_corr, self.mag[1]*br_temp_corr
+
     def demagnetization(self, temperature=20):
         """return demagnetization Hx, Hy of this element"""
         return self.demag_b(self.flux_density(cosys='polar'), temperature)
@@ -1429,9 +1436,9 @@ class Element(BaseEntity):
             # assume polar coordinates of b
             pos = np.arctan2(self.center[1], self.center[0])
             #pos = 0  # cartesian
-            br_temp_corr = 1. + self.br_temp_coef*(temperature - 20.)
-            magn = np.sqrt(self.mag[0]**2 + self.mag[1]**2)*br_temp_corr
-            alfa = np.arctan2(self.mag[1], self.mag[0]) - pos
+            mag = self.remanence(temperature)
+            magn = np.sqrt(mag[0]**2 + mag[1]**2)
+            alfa = np.arctan2(mag[1], mag[0]) - pos
             b1, b2 = b
             bpol = b1 * np.cos(alfa) + b2 * np.sin(alfa)
             reluc = abs(self.reluc[0]) / (4*np.pi*1e-7 * 1000)
@@ -1505,6 +1512,43 @@ class SuperElement(BaseEntity):
         """return area of this superelement"""
         return sum([e.area for e in self.elements])
 
+    def get_rect_geom(self):
+        """return rectangle parameters of superelement:
+        x0, y0: center coordinates
+        w, h: width and height
+        alpha: angle of main axis"""
+        bxy = np.array([n.xy for b in self.nodechains
+                        for n in b.nodes[:-1]])
+        # center
+        cxy = np.mean(bxy, axis=0)
+        # corner points: calculate angles
+        b = np.vstack((bxy[-1], bxy, bxy[0]))
+        a = np.arctan2(b[1:, 1]-b[:-1, 1],
+                       b[1:, 0]- b[:-1, 0])
+        peaks = np.where(np.abs(np.diff(a)) > 1)[0]
+        c = bxy[peaks]
+        # width and height
+        dxy = np.linalg.norm(np.vstack(
+            (bxy[:-1, :] - bxy[1:, :],
+             bxy[-1, :] - bxy[0, :])), axis=1)
+        dc = (np.sum(dxy[peaks[0]:peaks[1]]),
+              np.sum(dxy[peaks[1]:peaks[2]]),
+              np.sum(dxy[peaks[2]:peaks[3]]),
+              np.sum(np.hstack(
+                  (dxy[peaks[3]:], dxy[:peaks[0]]))))
+        w = np.mean(np.sort(dc)[-2:])
+        area = self.area()
+        h = area/w
+        # angle of main axis
+        i = np.argmax(dc)
+        c = np.vstack((c, c[0]))
+        alpha = np.arctan2(c[i+1, 1]-c[i, 1], c[i+1, 0]-c[i, 0])
+        if alpha < 0:
+            alpha += np.pi
+        return {'w': w, 'h': h, 'x0': cxy[0], 'y0': cxy[1],
+                'area': area, 'alpha': alpha}
+
+
 class SubRegion(BaseEntity):
     def __init__(self, key, sr_type, color, name, nturns, curdir, wb_key,
                  superelements, nodechains):

femagtools/losscoeffs.py

@@ -20,6 +20,11 @@ def pfe_jordan(f, B, ch, fh, cw, fw, fb, fo, Bo):
 def pfe_steinmetz(f, B, cw, fw, fb, fo, Bo):
     return cw*(f/fo)**fw * (B/Bo)**fb
 
+def pfe_modified_steinmetz(f, B, ch, cw, alpha, beta, fo, Bo):
+    return ch*(f/fo)*(B/Bo)**(alpha + B*beta) + cw*(f/fo)**2*(B/Bo)**2
+
+def wbert(f, b, ch, cw, cx):
+    return (ch + cw*f)*b**2 + cx*f**0.5*b**1.5
 
 def fitsteinmetz(f, B, losses, Bo, fo, alpha0=1.0):
     """fit coeffs of
@@ -56,6 +61,30 @@ def fitsteinmetz(f, B, losses, Bo, fo, alpha0=1.0):
             fbx, y, (1.0, 1.0, 2.0))
     return fitp
 
+def fit_modified_steinmetz(f, B, losses, Bo, fo):
+    """fit coeffs of modifeld steinmetz
+    losses(f,B)=ch*(f/fo)*(B/Bo)**(alpha + B*beta) + cw*(f/fo)**2*(B/Bo)**2
+    returns (ch, cw, alpha, beta)
+    """
+    pfe = losses
+    z = []
+    for i, fx in enumerate(f):
+        if fx:
+            if isinstance(B[0], float):
+                z += [(fx, bx, y)
+                      for bx, y in zip(B, pfe[i])
+                      if y]
+            else:
+                z += [(fx, bx, y)
+                      for bx, y in zip(B[i], pfe[i])
+                      if y]
+
+    fbx = np.array(z).T[0:2]
+    y = np.array(z).T[2]
+    fitp, cov = so.curve_fit(lambda x, ch, cw, alpha, beta: pfe_modified_steinmetz(
+        x[0], x[1], ch, cw, alpha, beta, fo, Bo),
+        fbx, y, (1.0, 1.0, 1.0, 1.0))
+    return fitp
 
 def fitjordan(f, B, losses, Bo, fo):
     """fit coeffs of
@@ -115,9 +144,6 @@ def fit_bertotti(f, B, losses):
         if j > 2:
             v.append(np.array((f[i0:j+i0], bb, y)).T.tolist())
 
-    def wbert(f, b, ch, cw, cx):
-        return (ch + cw*f)*b**2 + cx*f**0.5*b**1.5
-
     z = np.array([b for a in v for b in a]).T
     fbx = z[0:2]
     y = z[2]

femagtools/machine/afpm.py

@@ -15,6 +15,7 @@ from scipy.interpolate import make_interp_spline, RegularGridInterpolator, RectB
 from scipy.integrate import quad
 import copy
 from matplotlib.colors import to_rgb
+from multiprocessing import Pool
 
 logger = logging.getLogger(__name__)
 
@@ -54,7 +55,8 @@ def _integrate(radius, pos, val):
     interp = RegularGridInterpolator((radius, pos), val)
     def func(x, y):
         return interp((x, y))
-    return [quad(func, radius[0], radius[-1], args=(p,))[0]
+    return [quad(func, radius[0], radius[-1],
+                  args=(p,), limit=200)[0]
             for p in pos]
 
 
@@ -62,7 +64,7 @@ def _integrate1d(radius, val):
     interp = make_interp_spline(radius, val, k=1)
     def func(x):
         return interp((x))
-    return quad(func, radius[0], radius[-1])[0]
+    return quad(func, radius[0], radius[-1], limit=100)[0]
 
 def ld_interpol(i1, beta, v):
     '''interpolate Ld at beta angle 0°, -180°'''
@@ -152,7 +154,17 @@ def parident(workdir, engine, temp, machine,
         machine[wdgk].get('num_par_wdgs', 1))
 
     p = machine['poles']
-    num_slices = kwargs.get('num_slices', 3)
+    if np.isscalar(machine['magnet']['afm_rotor']['rel_magn_width']):
+        num_slices = kwargs.get('num_slices', 3)
+        rmagw = num_slices*[machine['magnet']['afm_rotor']['rel_magn_width']]
+    else:
+        rmagw = machine['magnet']['afm_rotor']['rel_magn_width']
+        if len(rmagw) == 1:
+            num_slices = kwargs.get('num_slices', 3)
+            rmagw = num_slices*list(rmagw)
+        else:
+            num_slices = len(rmagw)
+
     lfe = get_arm_lengths(machine['outer_diam'],
                           machine['inner_diam'],
                           num_slices)
@@ -172,6 +184,8 @@ def parident(workdir, engine, temp, machine,
         "decision_vars": [
             {"values": pole_width,
              "name": "pole_width"},
+            {"values": rmagw,
+             "name": "magnet.afm_rotor.rel_magn_width"},
             {"values": lfe,
              "name": "lfe"},
             {"values": linspeed, "name": "speed"}
@@ -216,9 +230,11 @@ def parident(workdir, engine, temp, machine,
         else:
             nlresults = {"x": [], "f": []}
             i = 0
-            for pw, le, sp in zip(pole_width, lfe, linspeed):
+
+            for pw, le, sp, rmw in zip(pole_width, lfe, linspeed, rmagw):
                 nlmachine = {k: machine[k] for k in machine}
                 nlmachine['pole_width'] = pw
+                nlmachine['magnet']['afm_rotor']['rel_magn_width'] = rmw
                 nlmachine['lfe'] = le
                 nlcalc.update({"speed": sp})
                 nlsubdir = f'{workdir}/{i}'
@@ -237,10 +253,11 @@ def parident(workdir, engine, temp, machine,
         current_angles = nlresults['f'][0]['current_angles']
         results = []
         i = 0
-        for l, pw in zip(lfe, pole_width):
+        for l, pw, rmw in zip(lfe, pole_width, rmagw):
             mpart = {k: machine[k] for k in machine if k != 'afm_rotor'}
             mpart['pole_width'] = pw
             mpart['lfe'] = l
+            mpart['magnet']['afm_rotor']['rel_magn_width'] = rmw
             subdir = f"{workdir}/{i}"
 
             simulation = dict(
@@ -296,12 +313,23 @@ def parident(workdir, engine, temp, machine,
             i += 1
 
         postp = []
-        for results in [process(lfe, pole_width, machine, bch)
-                        for bch in zip(*[r['f'] for r in results])]:
-            torque = np.mean(results.pop('torque'))
-            results['torque'] = torque
-            results.update(_psidq_ldq(results, nlresults))
-            postp.append(results)
+        if kwargs.get('use_multiprocessing', True):
+            with Pool() as p:
+                for r in p.starmap(process,
+                                   [(lfe, pole_width, machine, bch)
+                                    for bch in zip(*[r['f']
+                                                     for r in results])]):
+                    torque = np.mean(r.pop('torque'))
+                    r['torque'] = torque
+                    r.update(_psidq_ldq(r, nlresults))
+                    postp.append(r)
+        else:
+            for r in [process(lfe, pole_width, machine, bch)
+                      for bch in zip(*[r['f'] for r in results])]:
+                torque = np.mean(r.pop('torque'))
+                r['torque'] = torque
+                r.update(_psidq_ldq(r, nlresults))
+                postp.append(r)
 
         r1 = postp[0]['r1']
         i1 = [r['i1'] for r in postp][::num_beta_steps]
@@ -396,6 +424,7 @@ def process(lfe, pole_width, machine, bch):
     n = len(rotpos[0])
     currents = [bch[0]['flux'][k][0]['current_k'][:n]
                 for k in bch[0]['flux']]
+
     if len(pole_width) > 1:
         # check homogenity:
         if np.diff([len(d) for d in displ]).any():
@@ -427,6 +456,9 @@ def process(lfe, pole_width, machine, bch):
                        for ux in bch[0]['flux'][k][0]['voltage_dpsi'][:-1]]
                    for k in bch[0]['flux']}
         emf = [voltage[k][:n] for k in voltage]
+        fluxxy = {k: [scale_factor * np.array(flx)
+                      for flx in bch[0]['flux'][k][0]['flux_k']]
+                  for k in bch[0]['flux']}
         flux = [fluxxy[k][:n] for k in fluxxy]
 
     pos = (rotpos[0]/np.pi*180)
@@ -485,7 +517,6 @@ def process(lfe, pole_width, machine, bch):
     except KeyError as exc:
         #logger.warning("missing key %s", exc)
         pass
-
     return {
         'weights': weights.tolist(),
         'pos': pos.tolist(), 'r1': r1,
@@ -646,13 +677,20 @@ def _draw_vertical_slots(ax,
     color = _get_colors(color, delta)
     taus = 2*np.pi/Q
     for n in range(Q):
-        beta = np.array([[n*taus+alpha[0], (n+1)*taus-alpha[0]],
-                         [(n+1)*taus-alpha[1], n*taus+alpha[1]]])
-        ax.fill(np.hstack((r * np.cos(beta[0, 0]),
-                           (r[::-1] * np.cos(beta[0, 1]))))+xoff,
-                np.hstack((r * np.sin(beta[0, 0]),
-                           (r[::-1] * np.sin(beta[0, 1]))))+yoff,
-                facecolor=color[0], edgecolor=color[0])
+        beta0 = np.linspace(n*taus, n*taus + taus/2-alpha[0], 5)
+        beta1 = np.linspace(n*taus, n*taus + taus/2-alpha[1], 5)
+        xr = np.concatenate((
+            r[0]*np.cos(beta0), r[1]*np.cos(beta1[::-1])))+xoff
+        yr = np.concatenate((
+            r[0]*np.sin(beta0), r[1]*np.sin(beta1[::-1])))+yoff
+        ax.fill(xr, yr, color=color[0])
+        beta0 = np.linspace(n*taus + taus/2+alpha[0], (n+1)*taus, 5)
+        beta1 = np.linspace(n*taus + taus/2+alpha[1], (n+1)*taus, 5)
+        xr = np.concatenate((
+            r[0]*np.cos(beta0), r[1]*np.cos(beta1[::-1])))+xoff
+        yr = np.concatenate((
+            r[0]*np.sin(beta0), r[1]*np.sin(beta1[::-1])))+yoff
+        ax.fill(xr, yr, color=color[0])
 
 
 def vertical_plot(machine, ax):
@@ -669,7 +707,10 @@ def vertical_plot(machine, ax):
     model_type = machine['afmtype'][0:4]
     dy1 = machine['outer_diam']*1e3
     dy2 = machine['inner_diam']*1e3
-    rel_magn_width = machine['magnet']['afm_rotor']['rel_magn_width']
+    try:
+        rel_magn_width = max(machine['magnet']['afm_rotor']['rel_magn_width'])
+    except TypeError:
+        rel_magn_width = machine['magnet']['afm_rotor']['rel_magn_width']
     Q = machine['stator']['num_slots']
     slot_width = machine['stator']['afm_stator']['slot_width']*1e3
     poles = machine['poles']
@@ -818,7 +859,10 @@ def horizontal_plot(machine, ax):
     model_type = machine['afmtype'][0:4]
     dy1 = machine['outer_diam']*1e3
     dy2 = machine['inner_diam']*1e3
-    rel_magn_width = machine['magnet']['afm_rotor']['rel_magn_width']
+    try:
+        rel_magn_width = max(machine['magnet']['afm_rotor']['rel_magn_width'])
+    except TypeError:
+        rel_magn_width = machine['magnet']['afm_rotor']['rel_magn_width']
     magn_height = machine['magnet']['afm_rotor']['magn_height']*1e3
     magn_yoke_height = machine['magnet']['afm_rotor']['yoke_height']*1e3
 
@@ -911,6 +955,14 @@ class AFPM:
         except KeyError:
             raise ValueError("missing key afmtype")
 
+        if np.isscalar(machine['magnet']['afm_rotor']['rel_magn_width']):
+            rmagw = num_slices*[machine['magnet']['afm_rotor']['rel_magn_width']]
+        else:
+            rmagw = machine['magnet']['afm_rotor']['rel_magn_width']
+            if len(rmagw) == 1:
+                rmagw = num_slices*list(rmagw)
+            elif num_slices != len(rmagw):
+                num_slices = len(rmagw)
         lfe = get_arm_lengths(machine['outer_diam'],
                               machine['inner_diam'],
                               num_slices)
@@ -934,11 +986,20 @@ class AFPM:
                  "name": "pole_width"},
                 {"values": lfe,
                  "name": "lfe"},
+                {"values": rmagw,
+                 "name": "magnet.afm_rotor.rel_magn_width"},
                 {"values": linspeed, "name": "speed"}
             ]
         }
+
         machine['pole_width'] = np.pi * machine['inner_diam']/machine['poles']
         machine['lfe'] = machine['outer_diam'] - machine['inner_diam']
+        try:
+            machine['magnet']['afm_rotor']['rel_magn_width'] = max(
+                machine['magnet']['afm_rotor']['rel_magn_width'])
+        except TypeError:
+            pass
+
         simulation['skew_displ'] = (simulation.get('skew_angle', 0)/180 * np.pi
                                     * machine['inner_diam'])
         nlresults = {}

femagtools/mcv.py

@@ -298,6 +298,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 +361,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 +376,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 +498,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 +597,7 @@ 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 +630,24 @@ class Writer(Mcv):
                          float(self.mc1_fe_spez_weigth),
                          float(self.mc1_fe_sat_magnetization)])
 
+        logger.info(f"fo = {float(self.mc1_base_frequency)}")
+        logger.info(f"Bo = {float(self.mc1_base_induction)}")
+        logger.info(f"ch = {float(self.mc1_ch_factor)}")
+        logger.info(f"cw = {float(self.mc1_cw_factor)}")
+        logger.info(f"ch_freq = {float(self.mc1_ch_freq_factor)}")
+        logger.info(f"cw_freq = {float(self.mc1_cw_freq_factor)}")
+        logger.info(f"b_coeff = {float(self.mc1_induction_factor)}")
+        logger.info(f"fr_spez_weight = {float(self.mc1_fe_spez_weigth)}")
+        logger.info(f"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 +708,18 @@ 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:
+                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("losses_cw = %f, losses_cw_freq = %f, losses_b_coeff = %f, losses_fo = %f, losses_Bo = %f",
+                             self.losses['cw'], self.losses['cw_freq'],
+                             self.losses['b_coeff'], self.losses['fo'], self.losses['Bo'])
             self.writeBlock([1])
             logger.info('Losses n freq %d n ind %d', nfreq, nind)
         except Exception as e:
@@ -1175,6 +1211,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/multiproc.py

@@ -56,7 +56,8 @@ class ProgressLogger(threading.Thread):
                         ["progress_logger",
                          f"{self.numTot}:{numOf}:{percent}:{' '.join(summary)}"])
             else:
-                logger.info('collecting FE losses ...')
+                # TODO: log message might be misleading
+                logger.debug('collecting FE losses ...')
                 return
 
     def stop(self):

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/__init__.py

@@ -1,6 +1,7 @@
 """Creating plots
 
 """
+from .machine import machine
 from .fluxdens import airgap, airgap_fft
 from .bch import torque, torque_fft, force, force_fft, \
     fluxdens_surface, winding_current, winding_flux, \