femagtools 1.7.9__py3-none-any.whl → 1.8.1__py3-none-any.whl

femagtools/fsl.py

@@ -95,12 +95,12 @@ class Builder:
         if templ in ('statorFsl', 'dxf'):
             self.fsl_stator = True
 
-        if templ != 'dxffile':
+        if templ not in ('dxffile', 'svgfile'):
             return
 
         from femagtools.dxfsl.converter import convert
         logger.info("Conv stator from %s",
-                    model.stator['dxffile']['name'])
+                    model.stator[templ]['name'])
         params = {}
         params['split'] = model.stator[templ].get('split', False)
         params['show_plots'] = model.stator[templ].get('plot', False)
@@ -109,7 +109,7 @@ class Builder:
         params['nodedist'] = model.stator.get('nodedist', 1)
         pos = 'in' if model.external_rotor else 'out'
         params['part'] = ('stator', pos)
-        conv = convert(model.stator['dxffile']['name'], **params)
+        conv = convert(model.stator[templ]['name'], **params)
 
         model.stator['num_slots'] = conv.get('tot_num_slot')
         model.set_value('poles', conv.get('num_poles'))
@@ -157,10 +157,18 @@ class Builder:
                     + model.stator['dxf']['fsl'])
         if templ == 'statorFsl':
             #  obsolete
+            th_props = [' ']
+            try: 
+                th_props = [f'stator_density = {model.stator["density"]}',
+                            f'stator_thcond = {model.stator["thcond"]}',
+                            f'stator_thcap = {model.stator["thcap"]}',
+                            ]
+            except: 
+                pass 
             if 'parameter' in model.stator['statorFsl']:
                 return self.render_template(
                     model.stator['statorFsl']['content_template'],
-                    model.stator['statorFsl']['parameter'])
+                    model.stator['statorFsl']['parameter']) + th_props
             elif model.stator['statorFsl'].get('content'):
                 return (['agndst = {}'.format(model.get('agndst', 1e-3)*1e3),
                         'ndt(agndst)'] +
@@ -214,16 +222,24 @@ class Builder:
                .format(model.magnet.get('mcvkey_yoke', 'dummy')),
                "mcvkey_shaft = '{}'"
                .format(model.magnet.get('mcvkey_shaft', 'dummy'))]
-
         if 'magnetFsl' in model.magnet:
             self.fsl_rotor = True
             #  obsolete
+            th_props = [' ']
+            try: 
+                logger.info(model.magnet)
+                th_props = [f'rotor_density = {model["magnet"]["density"]}',
+                            f'rotor_thcond = {model["magnet"]["thcond"]}',
+                            f'rotor_thcap = {model["magnet"]["thcap"]}'
+                            ]
+            except: 
+                pass 
             if 'parameter' in model.magnet['magnetFsl']:
                 return mcv + self.render_template(
                     model.magnet['magnetFsl']['content_template'],
-                    model.magnet['magnetFsl']['parameter'])
+                    model.magnet['magnetFsl']['parameter']) + th_props
             elif model.magnet['magnetFsl'].get('content'):
-                return mcv + model.magnet['magnetFsl']['content'].split('\n')
+                return mcv + model.magnet['magnetFsl']['content'].split('\n') 
             if isinstance(model.magnet['magnetFsl']
                           ['content_template'], str):
                 with open(model.magnet['magnetFsl']
@@ -231,9 +247,8 @@ class Builder:
                     templ = [l.strip() for l in f.readlines()]
             else:
                 templ = model.magnet['magnetFsl']['content_template']
-
             return mcv + self.render_template(
-                '\n'.join(templ),
+                '\n'.join(templ), 
                 model.magnet['magnetFsl'])
 
         templ = model.magnettype()
@@ -311,7 +326,7 @@ class Builder:
         if templ == 'dxf':
             # reuse dxfsl model
             self.fsl_rotor = True
-        if templ != 'dxffile':
+        if templ not in ('dxffile', 'svgfile'):
             return
 
         from femagtools.dxfsl.converter import convert
@@ -367,7 +382,9 @@ class Builder:
                     'beta = 360*m.npols_gen/m.num_poles',
                     'x3,y3 = pd2c(dy1/2,beta+m.zeroangl)',
                     'x4,y4 = pd2c(dy2/2,beta+m.zeroangl)',
-                    'def_bcond_tp(x1,y1,x2,y2,x3,y3,x4,y4, 4)',
+                    'if m.b_min == 0 then',
+                    '   def_bcond_tp(x1,y1,x2,y2,x3,y3,x4,y4, 4)',
+                    'end',
                     'state_of_problem("mag_static")']
             return fslcmds
         return []
@@ -433,12 +450,12 @@ class Builder:
         return []
 
     def create_gen_winding(self, model):
-        try: 
+        try:
             model.winding['wire'].update(
                 {"num_layers": model.winding["num_layers"]})
             genwdg = self.__render(model.winding,
                                     'gen_' + model.winding['wire'].get('name'))
-        except: 
+        except:
             genwdg = self.__render(model, 'gen_winding')
 
         k = list({'leak_dist_wind',
@@ -467,30 +484,31 @@ class Builder:
                      'file_leak:close()'])
         return genwdg
 
-    def prepare_model_with_dxf(self, model):
+    def prepare_model_with_dxf_or_svg(self, model):
         from femagtools.dxfsl.converter import convert
-        dxfname = model.dxffile.get('name', None)
-        if not dxfname:
-            logger.error('Name of dxf-file expected')
+        fmt = model.dxffile if hasattr(model, 'dxffile') else model.svgfile
+        fname = fmt.get('name', None)
+        if not fname:
+            logger.error('Name of dxf or svg file expected')
             return []
 
-        if dxfname.split('.')[-1] not in ('dxf', 'svg'):  # add svg support
-            dxfname += '.dxf'
-        if not os.path.isfile(dxfname):
-            logger.error('File "%s" not found', dxfname)
-            raise ValueError(f'File {dxfname} not found')
+        if fname.split('.')[-1] not in ('dxf', 'svg'):  # add svg support
+            fname += fmt[:3]
+        if not os.path.isfile(fname):
+            logger.error('File "%s" not found', fname)
+            raise ValueError(f'File {fname} not found')
 
         params = {}
-        params['split'] = model.dxffile.get('split', False)
-        params['show_plots'] = model.dxffile.get('plot', False)
+        params['split'] = fmt.get('split', False)
+        params['show_plots'] = fmt.get('plot', False)
         params['write_fsl'] = True
-        params['airgap'] = model.dxffile.get('airgap', 0.0)
-        params['nodedist'] = model.dxffile.get('nodedist', 1)
-        params['full_model'] = model.dxffile.get('full_model', False)
-        params['EESM'] = model.dxffile.get('type', 'PMSM') == 'EESM'
+        params['airgap'] = fmt.get('airgap', 0.0)
+        params['nodedist'] = fmt.get('nodedist', 1)
+        params['full_model'] = fmt.get('full_model', False)
+        params['EESM'] = fmt.get('type', 'PMSM') == 'EESM'
         if params['EESM']:
             model.rotor['EESM'] = {}
-        conv = convert(dxfname, **params)
+        conv = convert(fname, **params)
 
         model.set_value('poles', conv.get('num_poles'))
         model.set_value('outer_diam', conv.get('dy1') * 1e-3)
@@ -524,7 +542,7 @@ class Builder:
             self.fsl_stator = True
             th_props = [' ']
             if model.stator.get('thcond', 0):
-                th_props = [f'stator_density = {1e3*model.stator["density"]}',
+                th_props = [f'stator_density = {model.stator["density"]}',
                             f'stator_thcond = {model.stator["thcond"]}',
                             f'stator_thcap = {model.stator["thcap"]}',
                             ]
@@ -538,10 +556,10 @@ class Builder:
         if 'fsl_rotor' in conv:
             self.fsl_rotor = True
             th_props = ['']
+            logger.info(model['magnet'])
             if hasattr(model, 'magnet'):
                 if model['magnet'].get('thcond', 0):
-                    logger.info(model['magnet'])
-                    th_props = [f'rotor_density = {1e3*model["magnet"]["density"]}',
+                    th_props = [f'rotor_density = {model["magnet"]["density"]}',
                                 f'rotor_thcond = {model["magnet"]["thcond"]}',
                                 f'rotor_thcap = {model["magnet"]["thcap"]}'
                                 ]
@@ -575,8 +593,8 @@ class Builder:
                 magnetMat['magntemp'] = 20
         if model.is_complete():
             logger.info("create new model '%s'", model.name)
-            if model.is_dxffile():
-                self.prepare_model_with_dxf(model)
+            if model.is_dxffile() or model.is_svgfile():
+                self.prepare_model_with_dxf_or_svg(model)
             else:
                 self.prepare_stator(model)
                 if hasattr(model, 'magnet'):
@@ -617,28 +635,6 @@ class Builder:
                                 f'magn_thcap = {model["magnet"]["thcap_magnet"]}'
                                 ]
                     rotor += th_props
-                    if model.is_dxffile() or 'dxf' in model['magnet']:
-                        rotor += ['if x0_shaft == 0.0 then',
-                                  '-- add air layer (inside) for heat transfer',
-                                  '   h = dy2/2/3',
-                                  '   if h > 5 then',
-                                  '      h = 3.8',
-                                  '   end ',
-                                  '   if m.zeroangl == nil then ',
-                                  '      m.zeroangl = 0.0',
-                                  '   end',
-                                  '   beta = 360*m.npols_gen/m.num_poles',
-                                  '   x0, y0 = pd2c(dy2/2, m.zeroangl)',
-                                  '   x1, y1 = pd2c(dy2/2-h, m.zeroangl)',
-                                  '   x2, y2 = pd2c(dy2/2-h, beta+m.zeroangl)',
-                                  '   x3, y3 = pd2c(dy2/2, beta+m.zeroangl)',
-                                  '   nc_line(x0, y0, x1, y1, 0)',
-                                  '   nc_circle(x1, y1, x2, y2, 0)',
-                                  '   nc_line(x2, y2, x3, y3, 0)',
-                                  '   x0, y0 = pd2c(dy2/2-h/2, beta/2+m.zeroangl)',
-                                  '   create_mesh_se(x0, y0)',
-                                'end'
-                                 ]
             else:
                 rotor = self.create_rotor_model(
                     model, condMat, ignore_material)

femagtools/machine/pm.py

@@ -148,7 +148,7 @@ class PmRelMachine(object):
             kr = self.zeta1[0]*freq**3 + self.zeta1[1]*freq**2 + \
                 self.zeta1[2]*freq + self.zeta1[3]
             kr[kr<1] = 1.
-            return self.r1*(1 - self.kth1*(self.tcu1 - 20))*kr  # ref 20°C
+            return self.r1*(1 + self.kth1*(self.tcu1 - 20))*kr  # ref 20°C
         if self.skin_resistance is not None:
             return self.skin_resistance(self.r1, w, self.tcu1, kth=self.kth1)
 

femagtools/machine/sm.py

@@ -339,6 +339,20 @@ class SynchronousMachine(object):
 
     def rstat(self, w):
         """stator resistance"""
+        if isinstance(self.zeta1, list):
+            # polyfit from ac loss calculation
+            freq = w/2/np.pi
+            kr = self.zeta1[0]*freq**3 + self.zeta1[1]*freq**2 + \
+                self.zeta1[2]*freq + self.zeta1[3]
+            if isinstance(kr, list):
+                kr = np.array(kr)
+                kr[kr<1.0] = 1.0
+            elif isinstance(kr, np.ndarray):
+                kr[kr<1.0] = 1.0
+            else:
+                if kr < 1.0:
+                    kr = 1.0
+            return self.r1*(1 + self.kth1*(self.tcu1 - 20))*kr  # ref 20°C
         sr = self.skin_resistance[0]
         if sr is not None:
             return sr(self.r1, w, self.tcu1, kth=self.kth1)
@@ -792,10 +806,7 @@ class SynchronousMachinePsidq(SynchronousMachine):
             if 'styoke_excess' in eecpars[idname][0]['losses'] and \
                np.any(np.array(eecpars[idname][0]['losses']['styoke_excess'])):
                 self.bertotti = True
-                keys.update({{
-                    'styoke_excess': 1.5,
-                    'stteeth_excess':1.5,
-                    'rotor_excess': 1.5}})
+                keys += ['styoke_excess', 'stteeth_excess','rotor_excess']
             if islinear:
                 pfe = {k: np.array([l['losses'][k]
                                     for l in eecpars[idname]])
@@ -912,10 +923,7 @@ class SynchronousMachineLdq(SynchronousMachine):
             if 'styoke_excess' in eecpars[idname][0]['losses'] and \
                np.any(np.array(eecpars[idname][0]['losses']['styoke_excess'])):
                 self.bertotti = True
-                keys.update({{
-                    'styoke_excess': 1.5,
-                    'stteeth_excess':1.5,
-                    'rotor_excess': 1.5}})
+                keys += ['styoke_excess', 'stteeth_excess','rotor_excess']
 
             if islinear:
                 pfe = {k: np.array([l['losses'][k]

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