femagtools 1.8.2__py3-none-any.whl → 1.8.3__py3-none-any.whl

femagtools/machine/afpm.py

@@ -33,16 +33,21 @@ def num_agnodes(Q, p, pw, ag):
       pw: (float) pole width
       ag: (float) airgap height
     """
-    num_nodes = np.arange(12, 120, 6)
+    num_nodes = np.arange(6, 120, 6)
     i = np.argmin(np.abs(pw/num_nodes - ag/2))
-    if p*num_nodes[i-1] % Q:
+    nag = num_nodes[i-1]
+    if p*nag % Q:
         lcm = np.lcm(Q, 2*p)//p
-        nmin, nmax = num_nodes[0]//lcm, num_nodes[-1]//lcm
+        nmin, nmax = 1, num_nodes[-1]//lcm
         num_nodes = np.array(
             [i*lcm for i in range(nmin, nmax) if i*lcm % 6 == 0])
         i = np.argmin(np.abs(pw/num_nodes - ag/2))
-        # nodedist 0.5, 2, 4, 6
-    return num_nodes[i-1]
+        if i > 0:
+            nag = num_nodes[i-1]
+        else:
+            nag = num_nodes[i]
+        # TODO nodedist 0.5, 2, 4, 6
+    return nag
 
 def _integrate(radius, pos, val):
     interp = RegularGridInterpolator((radius, pos), val)
@@ -162,7 +167,6 @@ def parident(workdir, engine, temp, machine,
         for pw in pole_width:
             machine['num_agnodes'] = num_agnodes(Q1, p//2, pw,
                                                  machine['airgap'])
-
     nlparvardef = {
         "decision_vars": [
             {"values": pole_width,
@@ -182,13 +186,13 @@ def parident(workdir, engine, temp, machine,
     parvardef = {
         "decision_vars": [
             #            {"values": sorted(2*temp), "name": "magn_temp"},
-            {"steps": num_beta_steps, "bounds": [beta_min, 0], "name": "angl_i_up"},
+            {"steps": num_beta_steps, "bounds": [beta_min, 0],
+             "name": "angl_i_up"},
             {"steps": num_cur_steps,
              "bounds": [i1_max/num_cur_steps, i1_max], "name": "current"}
         ]
     }
 
-
     ldq = []
     for magtemp in temp:
         nlcalc = dict(
@@ -381,7 +385,7 @@ def process(lfe, pole_width, machine, bch):
     num_slots = machine['stator']['num_slots']
     mmod = model.MachineModel(machine)
     slots_gen = mmod.stator['num_slots_gen']
-    scale_factor =_get_scale_factor(model_type, num_slots, slots_gen)
+    scale_factor = _get_scale_factor(model_type, num_slots, slots_gen)
     endpos = [2*pw*1e3 for pw in pole_width]
     displ = [[d for d in r['linearForce'][0]['displ']
               if d < e*(1+1/len(r['linearForce'][0]['displ']))]
@@ -392,11 +396,14 @@ def process(lfe, pole_width, machine, bch):
     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():
+            raise ValueError(
+                f"inhomogenous number of steps: {[len(d) for d in displ]}")
+        lfx = [r['linearForce'][0]['force_x'] for r in bch]
         torque = _integrate(radius, rotpos[0], np.array(
             [r*scale_factor*np.array(fx[:-1])/l
-             for l, r, fx in zip(lfe, radius,
-                                 [r['linearForce'][0]['force_x']
-                                  for r in bch])]))
+             for l, r, fx in zip(lfe, radius, lfx)]))
 
         voltage = {k: [scale_factor * np.array(ux[:-1])/l
                        for l, ux in zip(lfe, [r['flux'][k][0]['voltage_dpsi']
@@ -404,6 +411,13 @@ def process(lfe, pole_width, machine, bch):
                    for k in bch[0]['flux']}
         emf = [_integrate(radius, rotpos[0], np.array(voltage[k]))
                for k in voltage]
+
+        fluxxy = {k: [scale_factor * np.array(flx[:-1])/l
+                      for l, flx in zip(lfe, [r['flux'][k][0]['flux_k']
+                                              for r in bch])]
+                  for k in bch[0]['flux']}
+        flux = [_integrate(radius, rotpos[0], np.array(fluxxy[k]))
+                for k in fluxxy]
     else:
         r = radius[0]
         torque = [r*scale_factor*fx
@@ -412,6 +426,7 @@ 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]
+        flux = [fluxxy[k][:n] for k in fluxxy]
 
     pos = (rotpos[0]/np.pi*180)
     emffft = utils.fft(pos, emf[0])
@@ -474,6 +489,7 @@ def process(lfe, pole_width, machine, bch):
         'weights': weights.tolist(),
         'pos': pos.tolist(), 'r1': r1,
         'torque': torque,
+        'flux_k': flux,
         'emf': emf,
         'emf_amp': emffft['a'], 'emf_angle': emffft['alfa0'],
         'freq': freq,
@@ -591,10 +607,10 @@ class AFPM:
     condMat: conductor material
     """
     def __init__(self, workdir, magnetizingCurves='.', magnetMat='',
-                 condMat=''):
+                 condMat='', cmd=None):
         self.parstudy = parstudy.List(
             workdir, condMat=condMat, magnets=magnetMat,
-            magnetizingCurves=magnetizingCurves)
+            magnetizingCurves=magnetizingCurves, cmd=cmd)
 
     def __call__(self, engine, machine, simulation, num_slices):
         """ run FE simulation
@@ -648,21 +664,24 @@ class AFPM:
         }
         machine['pole_width'] = np.pi * machine['inner_diam']/machine['poles']
         machine['lfe'] = machine['outer_diam'] - machine['inner_diam']
-
+        simulation['skew_displ'] = (simulation.get('skew_angle', 0)/180 * np.pi
+                                    * machine['inner_diam'])
         nlresults = {}
-        if (simulation['calculationMode'] != 'cogg_calc' and
-            'poc' not in simulation):
+        if (simulation['calculationMode'] != 'cogg_calc'
+            and 'poc' not in simulation):
             nlcalc = dict(
                 calculationMode="cogg_calc",
                 magn_temp=simulation.get('magn_temp', 20),
                 num_move_steps=60,
+                skew_linear=0,
+                skew_steps=0,
                 poc=poc.Poc(machine['pole_width']),
                 speed=0)
             logging.info("Noload simulation")
             nlresults = self.parstudy(parvardef,
                                       machine, nlcalc, engine)
             if nlresults['status'].count('C') != len(nlresults['status']):
-                raise ValueError('Noload simulation failed %s', nlresults['status'])
+                raise ValueError(f'Noload simulation failed {nlresults["status"]}')
             nlresults.update(process(lfe, pole_width, machine, nlresults['f']))
 
             current_angles = nlresults['f'][0]['current_angles']
@@ -671,14 +690,15 @@ class AFPM:
                 parameters={
                     'phi_voltage_winding': current_angles})
             logger.info("Current angles: %s", current_angles)
-        elif (simulation['calculationMode'] == 'cogg_calc' and
-            'poc' not in simulation):
+        elif (simulation['calculationMode'] == 'cogg_calc'
+            and 'poc' not in simulation):
             simulation['poc'] = poc.Poc(machine['pole_width'])
 
         lresults = self.parstudy(
-            parvardef,
-            {k: machine[k] for k in machine if k!= 'afm_rotor'},
-            simulation, engine)  # Note: imcomplete machine prevents rebuild
+            parvardef, machine, simulation, engine)
+        if lresults['status'].count('C') != len(lresults['status']):
+            raise ValueError(
+                f'{simulation["calculationMode"]} failed {lresults["status"]}')
 
         results = process(lfe, pole_width, machine, lresults['f'])
         if nlresults:

femagtools/machine/effloss.py

@@ -39,7 +39,7 @@ def iqd_tmech_umax(m, u1, with_mtpa, progress, speed_torque, iq, id, iex):
     finally:
         progress.close()
 
-def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa):
+def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa, publish=0):
     """calculate iqd for sm and pm using multiproc
     """
     progress_readers = []
@@ -79,6 +79,16 @@ def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa):
                 progress_readers.remove(r)
             else:
                 if i % len(progress_readers) == 0:
+                    if publish:
+                        numTot = len(collected_msg)
+                        numOf = f"{num_proc-numTot} of {num_proc}"
+                        workdone = sum([float(i[:-1])
+                                        for i in collected_msg]) / numTot
+                        logger.debug("numTot %d numOf %s workdone %s, %s",
+                                     numTot, numOf, workdone, collected_msg)
+                        publish(('progress_logger',
+                                 f"{numTot}:{numOf}:{workdone}:"))
+                        # {' '.join(collected_msg)}"))
                     logger.info("Losses/Eff Map: %s",
                                 ', '.join(collected_msg))
                     collected_msg = []
@@ -197,7 +207,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
       with_mtpa -- (optional) use mtpa if True (default), disables mtpv if False
       with_tmech -- (optional) use friction and windage losses (default)
       num_proc -- (optional) number of parallel processes (default 0)
-      progress  -- (optional) custom function for progress logging
+      progress  -- (optional) custom function for progress logging (publishing)
       with_torque_corr -- (optional) T is corrected if out of range (default False)
 
     Returns:
@@ -250,41 +260,42 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     logger.info("total speed,torque samples %d", ntmesh.shape[1])
     if isinstance(m, (PmRelMachine, SynchronousMachine)):
         if num_proc > 1:
-            iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa)
+            iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa,
+                                       publish=progress)
         else:
             class ProgressLogger:
-                def __init__(self, nsamples):
+                def __init__(self, nsamples, publish):
                     self.n = 0
+                    self.publish = publish
                     self.nsamples = nsamples
                     self.num_iv = round(nsamples/15)
                 def __call__(self, iqd):
                     self.n += 1
                     if self.n % self.num_iv == 0:
-                        logger.info("Losses/Eff Map: %d%%",
-                                    round(100*self.n/self.nsamples))
-            if progress is None:
-                progress = ProgressLogger(ntmesh.shape[1])
-            else:
-                try:
-                    progress.nsamples=ntmesh.shape[1]
-                    progress(0)  # To check conformity
-                    progress.n = 0
-                except:
-                    logger.warning("Invalid ProgressLogger given to efficiency_losses_map, using default one!")
-                    progress = ProgressLogger(ntmesh.shape[1])
+                        workdone=round(100*self.n/self.nsamples)
+                        if self.publish:
+                            self.publish(
+                                ('progress_logger',
+                                 f"{self.n}:{self.n} of {self.nsamples}:{workdone}"))
+                        logger.info("Losses/Eff Map: %d%%", workdone)
+
+            progress_logger = ProgressLogger(ntmesh.shape[1], progress)
+            progress_logger.nsamples = ntmesh.shape[1]
+            progress_logger(0)  # To check conformity
+            progress_logger.n = 0
             if with_tmech:
                 iqd = np.array([
                     m.iqd_tmech_umax(
                         nt[1],
                         2*np.pi*nt[0]*m.p,
-                        u1, log=progress, with_mtpa=with_mtpa)[:-1]
+                        u1, log=progress_logger, with_mtpa=with_mtpa)[:-1]
                     for nt in ntmesh.T]).T
             else:
                 iqd = np.array([
                     m.iqd_torque_umax(
                         nt[1],
                         2*np.pi*nt[0]*m.p,
-                        u1, log=progress, with_mtpa=with_mtpa)[:-1]
+                        u1, log=progress_logger, with_mtpa=with_mtpa)[:-1]
                     for nt in ntmesh.T]).T
 
         beta, i1 = betai1(iqd[0], iqd[1])

femagtools/machine/sizing.py

@@ -628,8 +628,9 @@ def get_sm_rotor_dimensions(A, psi1, lfe, Da2, par):
     mue0 = 4*np.pi*1e-7
 
     wf = wp - wc
-    anr = par['airgap']*par['Ba']/mue0/par['J']/par['kqr']
-
+    NI = par['airgap']*par['Ba']/mue0
+    anr = NI/par['J']/par['kqr']
+    r['NI'] = NI
     a = np.tan(alphap/2)/2
     b = (wp/2 - wc + np.tan(alphap/2)*(Da2/2 - hp))/2
     hc = min(max(4*anr/(wc+wp), 0.75*hfmax), hfmax)
@@ -827,7 +828,7 @@ def afpm(pnom: float, speed: float, p: int, afmtype: str, **kwargs) -> dict:
     bns = taus*(Di+2*hs1) - bds
 
     hns = (-bns + np.sqrt(bns**2 + 4*ans*np.tan(taus)))/2/np.tan(taus)/kps
-    hys = psi1/lfe/par['By']/kps
+    hys = psi1/2/lfe/par['By']/kps
 
     aw = ans * par['kq'] / layers / num_wires * kps
 

femagtools/machine/sm.py

@@ -434,9 +434,9 @@ class SynchronousMachine(object):
     def iqd_tmech(self, torque, n, disp=False, maxiter=500):
         """return currents for shaft torque with minimal losses"""
         if torque > 0:
-            startvals = self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = self.bounds[0][1], 0, self.bounds[-1][1]
         else:
-            startvals = -self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = -self.bounds[0][1]/2, 0, self.bounds[-1][1]
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -463,9 +463,9 @@ class SynchronousMachine(object):
     def iqd_torque(self, torque, disp=False, maxiter=500):
         """return currents for torque with minimal losses"""
         if torque > 0:
-            startvals = self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = self.bounds[0][1]/2, 0, self.bounds[-1][1]
         else:
-            startvals = -self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = -self.bounds[0][1]/2, 0, self.bounds[-1][1]
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -483,14 +483,14 @@ class SynchronousMachine(object):
             #options={'disp': disp, 'maxiter': maxiter})
             if res['success']:
                 return res.x
-            logger.warning("%s: torque=%f %f, io=%s",
-                           res['message'], torque, self.torque_iqd(*startvals),
-                           startvals)
+        logger.warning("%s: torque=%f %f, io=%s",
+                       res['message'], torque, self.torque_iqd(*startvals),
+                       startvals)
         raise ValueError(res['message'])
 
     def mtpa(self, i1max):
         """return iq, id, iex currents and maximum torque per current """
-        T0 = self.torque_iqd(np.sqrt(2)*i1max/2, 0, self.bounds[-1][1]/2)
+        T0 = self.torque_iqd(np.sqrt(2)*i1max, 0, self.bounds[-1][1])
         def i1tq(tq):
             return abs(i1max) - np.linalg.norm(self.iqd_torque(tq)[:2])/np.sqrt(2)
         with warnings.catch_warnings():
@@ -501,7 +501,7 @@ class SynchronousMachine(object):
 
     def mtpa_tmech(self, i1max, n):
         """return iq, id, iex currents and maximum torque per current """
-        T0 = self.torque_iqd(np.sqrt(2)*i1max/2, 0, self.bounds[-1][0])/2
+        T0 = self.torque_iqd(np.sqrt(2)*i1max, 0, self.bounds[-1][1])
         def i1tq(tq):
             return i1max - np.linalg.norm(self.iqd_tmech(tq, n)[:2])/np.sqrt(2)
         tq = so.fsolve(i1tq, T0)[0]
@@ -517,14 +517,11 @@ class SynchronousMachine(object):
             if log:
                 log(iqde)
             return (*iqde, torque)
-        beta, i1 = betai1(iqde[0], iqde[1])
-        iex = iqde[2]
+        #beta, i1 = betai1(iqde[0], iqde[1])
+        #iex = iqde[2]
 
-        def ubeta(b):
-            return np.sqrt(2)*u1max - np.linalg.norm(
-                self.uqd(w1, *iqd(b, i1), iex))
-        beta = -np.pi/4 if torque>0 else -3*np.pi/4
-        io = *iqd(beta, i1), iex
+        #beta = 0 if torque>0 else np.pi
+        io = iqde[0], 0, iqde[2] #*iqd(beta, i1), iex
 
         #    logger.debug("--- torque %g io %s", torque, io)
         with warnings.catch_warnings():
@@ -540,17 +537,18 @@ class SynchronousMachine(object):
                 bounds=self.bounds,
                 constraints=[
                     {'type': 'eq',
-                     'fun': lambda iqd: self.tmech_iqd(*iqd, n) - torque},
+                     'fun': lambda iqd: torque - self.tmech_iqd(*iqd, n)},
                     {'type': 'eq',
-                     'fun': lambda iqd: np.linalg.norm(
-                         self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}])
+                     'fun': lambda iqd: u1max*np.sqrt(2)
+                       - np.linalg.norm(self.uqd(w1, *iqd))}])
             #if res['success']:
-        if log:
-            log(res.x)
-        return *res.x, self.tmech_iqd(*res.x, n)
-    #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-    #               res['message'], w1, torque, u1max, io)
-    #raise ValueError(res['message'])
+            if log:
+                log(res.x)
+            return *res.x, self.tmech_iqd(*res.x, n)
+        #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+        #               res['message'], w1, torque, u1max, io)
+        #raise ValueError(res['message'])
+        #return [float('nan')]*4
 
     def iqd_torque_umax(self, torque, w1, u1max,
                         disp=False, maxiter=500, log=0, **kwargs):
@@ -579,16 +577,15 @@ class SynchronousMachine(object):
                     {'type': 'eq',
                      'fun': lambda iqd: self.torque_iqd(*iqd) - torque},
                     {'type': 'eq',
-                     'fun': lambda iqd: np.linalg.norm(
-                         self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}])
-            if res['success']:
-
-                if log:
-                    log(res.x)
-                return *res.x, self.torque_iqd(*res.x)
-            logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-                           res['message'], w1, torque, u1max, io)
-        raise ValueError(res['message'])
+                     'fun': lambda iqd: u1max*np.sqrt(2) - np.linalg.norm(
+                         self.uqd(w1, *iqd))}])
+            #if res['success']:
+            if log:
+                log(res.x)
+            return *res.x, self.torque_iqd(*res.x)
+            #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+            #               res['message'], w1, torque, u1max, io)
+            #raise ValueError(res['message'])
 
     def w1_imax_umax(self, i1max, u1max):
         """return frequency w1 and shaft torque at voltage u1max and current i1max
@@ -672,9 +669,10 @@ class SynchronousMachine(object):
 
         wmtab = []
         dw = 0
-        wmMax = 3.5*wmType
+        wmMax = 5*wmType
         if n > 0:
             wmMax = min(wmMax, 2*np.pi*n)
+
         if wmType > wmMax:
             wmrange = sorted([0, wmMax])
             wmtab = np.linspace(0, wmMax, nsamples).tolist()

femagtools/mcv.py

@@ -8,6 +8,7 @@ import sys
 import copy
 import logging
 import os.path
+import pathlib
 import struct
 import math
 import numpy as np
@@ -292,7 +293,12 @@ class Mcv(object):
         self.MC1_CW_FREQ_FACTOR = 0.0
         self.MC1_INDUCTION_FACTOR = 0.0
         self.MC1_INDUCTION_BETA_FACTOR = 0.0
-
+        self.jordan = {}
+        # {'ch': 0, 'cw': 0, 'ch_freq':0, 'cw_freq':0}
+        self.steinmetz = {}
+        # {'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.MC1_FE_SPEZ_WEIGTH = 7.65
         self.MC1_FE_SAT_MAGNETIZATION = 2.15
 
@@ -354,6 +360,9 @@ 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'):
+            if k in data:
+                self.__setattr__(k, data[k])
         self.curve = data['curve']
         try:
             self.mc1_angle = [c['angle'] for c in data['curve']]
@@ -363,6 +372,9 @@ class Mcv(object):
             self.losses = data['losses']
         except Exception:
             pass
+        # assume jordan iron loss parameters
+        for k in self.jordan:
+            self.jordan[k] = getattr(self, transl[k])
         return
 
     def rtrimValueList(self, vlist):
@@ -470,13 +482,25 @@ class Writer(Mcv):
                        for c in curve]
         return curve
 
-    def writeBinaryFile(self, fillfac=None, recsin=''):
+    def writeBinaryFile(self, fillfac=None, recsin='', feloss=''):
         """write binary file after conversion if requested.
         arguments:
         fillfac: (float) fill actor
         recsin: (str) either 'flux' or 'cur'
+        feloss: (str) iron loss method (bertotti, jordan)
         """
         curve = self._prepare(fillfac, recsin)
+        try:
+            if feloss.lower() == 'bertotti':
+                for k in self.bertotti:
+                    setattr(self, transl[k], self.bertotti[k])
+                del self.losses
+            else:
+                for k in self.jordan:
+                    setattr(self, transl[k], self.jordan[k])
+        except AttributeError as e:
+            logger.warning("%s", e)
+            pass
         mc1_type = self.mc1_type
         mc1_recalc = self.mc1_recalc
         mc1_fillfac = self.mc1_fillfac
@@ -556,6 +580,7 @@ class Writer(Mcv):
 
         try:
             if not (self.mc1_ch_factor or self.mc1_cw_factor) and self.losses:
+                # fit loss parameters
                 pfe = self.losses['pfe']
                 f = self.losses['f']
                 B = self.losses['B']
@@ -598,7 +623,8 @@ class Writer(Mcv):
             return
 
         try:
-            nfreq = len([1 for x in self.losses['f'] if x > 0])
+            freq = [x for x in self.losses['f'] if x > 0]
+            nfreq = len(freq)
             nind = len(self.losses['B'])
             if nind < 1 or nfreq < 1:
                 return
@@ -631,26 +657,28 @@ class Writer(Mcv):
             self.writeBlock([nfreq, nind])
             self.writeBlock([float(b) for b in B] + [0.0]*(M_LOSS_INDUCT - nind))
 
+            nrec = 0
             for f, p in zip(self.losses['f'], pfe):
                 if f > 0:
                     y = np.array(p)
                     losses = [float(x) for x in y[y != np.array(None)]]
-                    if len(losses) == nind:
-                        pl = p
+                    nloss = len(losses)
+                    if nloss == nind:
+                        pl = list(p)
                     else:
-                        n = len(losses)
                         cw, alfa, beta = lc.fitsteinmetz(
-                            f, B[:n], losses, Bo, fo)
+                            f, B[:nloss], losses, Bo, fo)
                         pl = losses + [lc.pfe_steinmetz(
                             f, b, cw, alfa, beta,
                             self.losses['fo'],
                             self.losses['Bo'])
-                                       for b in B[n:]]
+                                       for b in B[nloss:]]
                     logger.debug("%s", pl)
                     self.writeBlock(pl +
                                     [0.0]*(M_LOSS_INDUCT - len(pl)))
                     self.writeBlock(float(f))
-            for m in range(M_LOSS_FREQ - len(pfe)):
+                    nrec += 1
+            for m in range(M_LOSS_FREQ - nrec):
                 self.writeBlock([0.0]*M_LOSS_INDUCT)
                 self.writeBlock(0.0)
 
@@ -662,21 +690,21 @@ class Writer(Mcv):
         except Exception as e:
             logger.error("Exception %s", e, exc_info=True)
 
-    def writeMcv(self, filename, fillfac=None, recsin=''):
+    def writeMcv(self, filename, fillfac=None, recsin='', feloss='Jordan'):
         # windows needs this strip to remove '\r'
-        filename = filename.strip()
-        self.name = os.path.splitext(filename)[0]
+        filename = pathlib.Path(filename)
+        self.name = filename.stem
 
-        if filename.upper().endswith('.MCV') or \
-           filename.upper().endswith('.MC'):
+        if filename.suffix.upper() in ('.MCV', '.MC'):
             binary = True
-            self.fp = open(filename, "wb")
+            self.fp = filename.open(mode="wb")
         else:
             binary = False
-            self.fp = open(filename, "wb")
-        logger.info("Write File %s, binary format", filename)
+            self.fp = filename.open(mode="w")
+        logger.info("Write File %s, binary format (feloss '%s')",
+                    filename, feloss)
 
-        self.writeBinaryFile(fillfac, recsin)
+        self.writeBinaryFile(fillfac, recsin, feloss)
         self.fp.close()
 
 
@@ -737,17 +765,16 @@ class Reader(Mcv):
 
     def readMcv(self, filename):
         # intens bug : windows needs this strip to remove '\r'
-        filename = filename.strip()
+        filename = pathlib.Path(filename)
 
-        if filename.upper().endswith('.MCV') or \
-           filename.upper().endswith('.MC'):
+        if filename.suffix in ('.MCV', '.MC'):
             binary = True
-            self.fp = open(filename, "rb")
+            self.fp = filename.open(mode="rb")
         else:
             binary = False
-            self.fp = open(filename, "r")
+            self.fp = filename.open(mode="r")
 
-        self.name = os.path.splitext(os.path.basename(filename))[0]
+        self.name = filename.stem
         # read curve version (INTEGER)
         if binary:
             self.version_mc_curve = self.readBlock(int)
@@ -903,6 +930,8 @@ class Reader(Mcv):
         if self.MC1_INDUCTION_FACTOR > 2.0:
             self.MC1_INDUCTION_FACTOR = 2.0
 
+        # TODO: handle self.mc1_ce_factor, self.mc1_induction_beta_factor
+
         self.losses = {}
         try:
             (nfreq, njind) = self.readBlock([int, int])
@@ -1085,13 +1114,14 @@ class MagnetizingCurve(object):
                                 repls.items(), name)
 
     def writefile(self, name, directory='.',
-                  fillfac=None, recsin=''):
+                  fillfac=None, recsin='', feloss='jordan'):
         """find magnetic curve by name or id and write binary file
         Arguments:
           name: key of mcv dict (name or id)
           directory: destination directory (must be writable)
           fillfac: (float) new fill factor (curves will be recalulated if not None or 0)
           recsin: (str) either 'flux' or 'cur' recalculates for eddy current calculation (dynamic simulation)
+          feloss: (str) iron loss calc method ('jordan', 'bertotti', 'steinmetz')
 
         returns filename if found else None
         """
@@ -1125,7 +1155,7 @@ class MagnetizingCurve(object):
         filename = ''.join((bname, ext))
         writer = Writer(mcv)
         writer.writeMcv(os.path.join(directory, filename),
-                        fillfac=fillfac, recsin=recsin)
+                        fillfac=fillfac, recsin=recsin, feloss=feloss)
         return filename
 
     def fitLossCoeffs(self):