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

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.6'
+__version__ = '1.8.7'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2024 Gamma Technology'

femagtools/bch.py

@@ -1057,10 +1057,11 @@ class Reader:
         e.g. : idList[-450, -350, -250, -150, -50, 0]
                idList[-500, -400, -300, -200, -100, 0, 0]
         '''
-        diff = np.floor(np.abs(np.diff(idList)))
-        if idList[-1] == 0 and len(idList) > 2 and \
-           diff[-1] == 0:
+        if list(idList).count(0) > 1: # femag writes duplicate id==0 values
             idList = idList[:-1]
+        diff = np.floor(np.abs(np.diff(idList)))
+        if n := np.trim_zeros(np.diff(diff)).size:
+            idList = idList[:-n]
         return idList
 
     def __read_psidq(self, content):
@@ -1085,8 +1086,7 @@ class Reader:
             ncols = ncols-1
 
         id = np.reshape(m[0], (-1, ncols)).T[0]
-        if id[0] >= 0:
-            id = self.__removeTrailingZero(id)
+        id = self.__removeTrailingZero(id)
         nrows = len(id)
         if nrows > 1 and id[nrows-1] < id[nrows-2]:
             nrows = nrows-1
@@ -1121,8 +1121,7 @@ class Reader:
             ncols = ncols-1
 
         id = np.reshape(m[0], (-1, ncols)).T[0]
-        if id[0] >= 0:
-            id = self.__removeTrailingZero(id)
+        id = self.__removeTrailingZero(id)
         nrows = len(id)
         if nrows > 1 and id[nrows-1] < id[nrows-2]:
             nrows = nrows-1
@@ -1610,6 +1609,11 @@ class Reader:
                         losses['staza'] = floatnan(rec[0])
                         losses['stajo'] = floatnan(rec[1])
                         losses['total'] += losses['staza']+losses['stajo']
+
+                    elif content[i+1].split() == ['Iron', '----']:
+                        losses['rotfe'] = sum([floatnan(x) for x in rec])
+                        losses['total'] += losses['rotfe']    
+                        
                     else:
                         losses['rotfe'] = floatnan(rec[1])
                         losses['total'] += losses['rotfe']

femagtools/femag.py

@@ -61,43 +61,6 @@ def handle_process_output(filedes, outfile, log):
                         pass
 
 
-def get_shortCircuit_parameters(bch, nload):
-    try:
-        if nload < 0:
-            nload = 0
-        if nload > 2:
-            nload = 2
-        if nload > 0:
-            dqld = bch.dqPar['ld']
-            dqlq = bch.dqPar['lq']
-            dqpsim = bch.dqPar['psim']
-            if len(dqld) <= nload or len(dqlq) <= nload or len(dqpsim) <= nload:
-                ld = dqld[-1]/bch.armatureLength
-                lq = dqlq[-1]/bch.armatureLength
-                psim = dqpsim[-1]/bch.armatureLength
-            else:
-                ld = dqld[nload-1]/bch.armatureLength
-                lq = dqlq[nload-1]/bch.armatureLength
-                psim = dqpsim[nload-1]/bch.armatureLength
-        else:
-            ld = bch.machine['ld']/bch.armatureLength
-            lq = bch.machine['lq']/bch.armatureLength
-            psim = bch.machine['psim']/bch.armatureLength
-        return dict(
-            r1=bch.machine['r1'],
-            ld=ld,
-            lq=lq,
-            psim=psim,
-            num_pol_pair=bch.machine['p'],
-            fc_radius=bch.machine['fc_radius'],
-            lfe=bch.armatureLength/1e3,
-            pocfilename=bch.machine['pocfile'],
-            num_par_wdgs=bch.machine.get('num_par_wdgs', 0),
-            calculationMode='shortcircuit')
-    except (KeyError, AttributeError, IndexError):
-        raise FemagError("missing pm/Rel-Sim results")
-
-
 def set_magnet_properties(model, simulation, magnets):
     """set temperature adapted magnet properties"""
     if not hasattr(model, 'magnet'):
@@ -449,7 +412,7 @@ class BaseFemag(object):
 
         return list(pathlib.Path(self.workdir).glob('*.PROT'))[0].stem
 
-    def readResult(self, simulation, bch=None):
+    def readResult(self, machine, simulation, bch=None):
         if simulation:
             if simulation['calculationMode'] == "fieldcalc":
                 nc = self.read_nc()
@@ -495,38 +458,11 @@ class BaseFemag(object):
             if simulation['calculationMode'] == 'pm_sym_fast' or \
                 simulation['calculationMode'] == 'torq_calc':
                 if simulation.get('shortCircuit', False):
-                    logger.info("short circuit simulation")
-                    simulation.update(
-                        get_shortCircuit_parameters(bch,
-                                                    simulation.get('initial', 2)))
-
-                    builder = femagtools.fsl.Builder(self.templatedirs)
+                    from .shortcircuit import shortcircuit
                     set_magnet_properties(self.model, simulation, self.magnets)
-                    fslcmds = (builder.open_model(self.model) +
-                               builder.create_shortcircuit(simulation))
-                    fslfile = 'shortcicuit.fsl'
-                    with open(os.path.join(self.workdir, fslfile), 'w') as f:
-                        f.write('\n'.join(fslcmds))
-                    self.run(fslfile) #, options?
-                    bchfile = self.get_bch_file(self.modelname)
-                    if bchfile:
-                        bchsc = femagtools.bch.Reader()
-                        logger.info("Read BCH {}".format(bchfile))
-                        with io.open(bchfile, encoding='latin1',
-                                     errors='ignore') as f:
-                            bchsc.read(f)
-                    bch.scData = bchsc.scData
-                    for w in bch.flux:
-                        try:
-                            bch.flux[w] += bchsc.flux[w]
-                            bch.flux_fft[w] += bchsc.flux_fft[w]
-                        except (KeyError, IndexError):
-                            logging.debug(
-                                "No additional flux data in sc simulation")
-                            break
-
-                    bch.torque += bchsc.torque
-                    bch.demag += bchsc.demag
+                    bch.scData = shortcircuit(self, machine, bch, simulation)
+                    #bch.torque += bchsc.torque
+                    #bch.demag += bchsc.demag
 
             if 'airgap_induc' in simulation:
                 try:
@@ -699,8 +635,9 @@ class Femag(BaseFemag):
             setattr(self, "dy2", machine['stator']['dy2'])
         except:
             pass
+
         if simulation:
-            return self.readResult(simulation)
+            return self.readResult(machine, simulation)
 
         return {'status': 'ok', 'message': self.modelname,
                 'model': self.model.props()}
@@ -801,6 +738,7 @@ class ZmqFemag(BaseFemag):
     def subscribe(self, notify):
         """attaches a notify function"""
         logger.info("Subscribe on '%s' port %d", self.femaghost, self.port+1)
+        femagtools.zmq.SubscriberTask.clear()
         if self.subscriber is None:
             # progress/xyplot at a configured timestep published
             header = [b'progress', b'xyplot', b'license']

femagtools/fsl.py

@@ -227,7 +227,7 @@ class Builder:
             #  obsolete
             th_props = [' ']
             try:
-                logger.info(model.magnet)
+                logger.debug(model.magnet)
                 th_props = [f'rotor_density = {model["magnet"]["density"]}',
                             f'rotor_thcond = {model["magnet"]["thcond"]}',
                             f'rotor_thcap = {model["magnet"]["thcap"]}'
@@ -750,8 +750,11 @@ class Builder:
                 sim['eccentricity'])
 
         if sim.get('calculationMode') == 'pm_sym_f_cur':
-            if 'nload_ex_cur' in sim.keys():  # convert obsolete key
-                sim['noload_ex_cur'] = sim.pop('nload_ex_cur')
+            if sim.get('nload_ex_cur', ''):  # convert obsolete key
+                if isinstance(sim, dict):
+                    sim['noload_ex_cur'] = sim.pop('nload_ex_cur')
+                else:
+                    sim.noload_ex_cur = sim.get('nload_ex_cur')
         felosses = custom_fefunc + self.create_fe_losses(sim)
         fslcalc = (displ_stator_rotor
                    + self.__render(sim, sim.get('calculationMode'))

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

@@ -687,9 +687,9 @@ def _draw_vertical_slots(ax,
         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])))
+            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])))
+            r[0]*np.sin(beta0), r[1]*np.sin(beta1[::-1])))+yoff
         ax.fill(xr, yr, color=color[0])
 
 
@@ -707,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 = max(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']
@@ -856,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 = max(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
 
@@ -988,8 +994,11 @@ class AFPM:
 
         machine['pole_width'] = np.pi * machine['inner_diam']/machine['poles']
         machine['lfe'] = machine['outer_diam'] - machine['inner_diam']
-        machine['magnet']['afm_rotor']['rel_magn_width'] = max(
-            machine['magnet']['afm_rotor']['rel_magn_width'])
+        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'])

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/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):