femagtools 1.8.12__py3-none-any.whl → 1.8.14__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.12'
+__version__ = '1.8.14'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2025 Gamma Technology'

femagtools/bch.py

@@ -7,6 +7,7 @@ import numpy as np
 import re
 import logging
 import logging.config
+from .utils import fft
 
 logger = logging.getLogger('femagtools.bch')
 
@@ -114,6 +115,22 @@ def losses_mapping_external_rotor(losses):
         pass
     return d
 
+def _convert(obj):
+    """make dict jsonizable"""
+    if isinstance(obj, dict):
+        return {k: _convert(v) for k, v in obj.items()}
+    elif isinstance(obj, (np.float32, np.float64)):
+        return float(obj)
+    elif isinstance(obj, list):
+        return [_convert(k) for k in obj]
+    elif isinstance(obj, tuple):
+        return tuple(_convert(k) for k in obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif isinstance(obj, (np.int32, np.int64)):
+        return int(obj)
+    else:
+        return obj
 
 def _readSections(f):
     """return list of bch sections
@@ -1057,11 +1074,14 @@ class Reader:
         e.g. : idList[-450, -350, -250, -150, -50, 0]
                idList[-500, -400, -300, -200, -100, 0, 0]
         '''
-        if list(idList).count(0) > 1: # femag writes duplicate id==0 values
+        if list(idList).count(0) > 1:  # femag may write 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]
+        maxdiff = np.max(diff)
+        # also remove samples that are close
+        if n := np.trim_zeros(np.diff(
+                np.round(diff/maxdiff, 2))).size:
+            return idList[:-n]
         return idList
 
     def __read_psidq(self, content):
@@ -1375,10 +1395,14 @@ class Reader:
             try:
                 w1 = np.pi*self.dqPar['speed']*self.dqPar['npoles']
                 r1 = self.machine.get('r1', 0.0)
-                uq, ud = (r1*iq + self.dqPar['up'] + id*w1*self.dqPar['ld'][0],
-                          r1*id - iq*w1*self.dqPar['lq'][0])
-                self.dqPar['u1'] = [np.sqrt(uq**2 + ud**2)]
-                self.dqPar['gamma'] = [-np.arctan2(ud, uq)*180/np.pi]
+                pos = self.flux['1'][0]['displ']
+                emfft = [fft(pos, f['voltage_dpsi']) for f in self.flux['1']]
+                gamma = [emfft[0]['alfa0'] - e['alfa0'] for e in emfft[1:]]
+                emf = np.array([e['a']/np.sqrt(2) for e in emfft[1:]])
+                uq, ud = r1*iq + np.cos(gamma)*emf, r1*id + np.sin(gamma)*emf
+                self.dqPar['u1'] = np.sqrt(uq**2 + ud**2).tolist()
+                self.dqPar['gamma'] = (-np.arctan2(ud, uq)*180/np.pi).tolist()
+
                 self.dqPar['psim0'] = lfe*self.dqPar['psim0']
                 self.dqPar['phi'] = [self.dqPar['beta'][0] +
                                      self.dqPar['gamma'][0]]
@@ -1386,16 +1410,22 @@ class Reader:
                                         for phi in self.dqPar['phi']]
                 self.dqPar['i1'].insert(0, 0)
                 self.dqPar['u1'].insert(0, self.dqPar.get('up0', 0))
+
             except KeyError:
                 pass
 
-            # if next section is absent
             try:
-                self.dqPar['psid'] = [self.dqPar['psim'][0]]
-                self.dqPar['psiq'] = [self.dqPar['lq'][0] *
-                                      self.dqPar['i1'][-1]]
-            except KeyError:
-                pass
+                self.dqPar['psid'] = list(np.cos(gamma)*emf/w1)
+                self.dqPar['psiq'] = list(-np.sin(gamma)*emf/w1)
+            except UnboundLocalError:
+                try:
+                    self.dqPar['psid'] = [self.dqPar['psim'][0]]
+                    self.dqPar['psiq'] = [self.dqPar['lq'][0] *
+                                          self.dqPar['i1'][-1]]
+                except KeyError:
+                    pass
+
+            self.dqPar = _convert(self.dqPar)
             return  # end of first section
 
         # second DQ-Parameter section
@@ -1467,6 +1497,7 @@ class Reader:
             self.dqPar['u1'].insert(0, self.dqPar.get('up0', 0))
         except:
             pass
+        self.dqPar = _convert(self.dqPar)
 
     def __read_weights(self, content):
         #              Stator-Iron      - Conductors      - Magnets
@@ -1612,8 +1643,8 @@ class Reader:
 
                     elif content[i+1].split() == ['Iron', '----']:
                         losses['rotfe'] = sum([floatnan(x) for x in rec])
-                        losses['total'] += losses['rotfe']    
-                        
+                        losses['total'] += losses['rotfe']
+
                     else:
                         losses['rotfe'] = floatnan(rec[1])
                         losses['total'] += losses['rotfe']
@@ -1836,6 +1867,9 @@ def read(filename):
 
 if __name__ == "__main__":
     import json
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s %(message)s')
+
     if len(sys.argv) == 2:
         filename = sys.argv[1]
     else:

femagtools/ecloss.py

@@ -263,10 +263,11 @@ class MagnLoss:
                                    for i in range((npos-1)//2 + 1) if i > 0])
             npos_nonzero = np.argwhere(tmp_period > 0.1*np.amax(bxy_amp)).squeeze()
             period = tmp_period[npos_nonzero]
-
             if np.sum(np.around([period[0]%i for i in period])) == 0:
-                npos = min(int(np.ceil(np.amax(period))+1), bxy.shape[2])
-
+                try:
+                    npos = min(int(np.ceil(np.amax(period))+1), bxy.shape[2])
+                except:
+                    pass
         try:
             self.tgrid = 60/self.speed*(self.theta[npos-1] - self.theta[0])/360
         except AttributeError:
@@ -765,7 +766,12 @@ class MagnLoss:
                             i["wm"]*1e3, i["hm"]*1e3, i["lm"]*1e3,
                             (nsegx, nsegy, nsegz))
 
-                (nt, bx_fft, by_fft) = self.periodicity_id(i['bl'])  # finds the time periodic part of the simulation
+                (nt, bx_fft, by_fft) = self.periodicity_id(i['bl'])
+                if self.tgrid == 0:
+                    logger.warning(f"Time series couldn't be identified. Cannot calculate losses \
+                                   for loadcase {i['loadcase']}, superelement {i['spel_key']}")
+                    all_load_cases.append(0)
+                    continue
                 (nx, ny, nz, excpl_new, eycpl_new) = Segmentation(
                     i['wm'], i['hm'], i['lm'], i['elcp'],
                     nsegx, nsegy, nsegz)
@@ -778,6 +784,8 @@ class MagnLoss:
                     nx, ny, nsegx, nsegy, nt, i['elcp'], i['bl'], excpl_new, eycpl_new)
                 loss = self.loss_ialh2(sx_abs, sy_abs, sx_phase, sy_phase, freq_range,
                                        nx, ny, wm, hm, lm, nsegx, nsegy, nsegz, delta_eff) * self.numpoles
+                if np.isnan(loss):
+                    loss = 0
                 ialh_loss += loss
                 logger.info('Loadcase %d, Superelement %s, Total losses =  %.3f W',
                             i["loadcase"], i["spel_key"], loss)

femagtools/femag.py

@@ -475,9 +475,8 @@ class BaseFemag(object):
             if simulation.get('magnet_loss', False):
                 logger.info('Evaluating magnet losses...')
                 ops = range(len(bch.torque))
-                ncf = pathlib.Path(self.workdir) / self.modelname
                 m = femagtools.ecloss.MagnLoss(
-                    nc=femagtools.nc.read(ncf), ibeta=ops)
+                    nc=self.read_nc(), ibeta=ops)
                 try:
                     # change from ialh to ialh2: since v1.8.1
                     magn_losses = m.calc_losses_ialh2()
@@ -486,6 +485,8 @@ class BaseFemag(object):
 
                 if len(ops) != len(bch.losses):
                     magn_losses.insert(0, magn_losses[0])
+                
+                magn_losses = [float(i) for i in magn_losses]
                 try:
                     for i in range(len(bch.losses)):
                         bch.losses[i].update({"magnetH": magn_losses[i]})

femagtools/fsl.py

@@ -436,25 +436,38 @@ class Builder:
         return self.__render(windings, 'cu_losses')
 
     def create_fe_losses(self, model):
-        for part in ('stator', 'rotor', 'commutator', 'magnet'):
+        fe_losses = []
+        fe_losses_items = (
+            'ffactor', 'cw', 'ch', 'hyscoef',
+            'edycof', 'indcof', 'fillfact',
+            'fillfac', 'basfreq', 'basind',
+            'ffactor')
+
+        part = 'stator'
+        if model.get(part, 0):
+            submod = model.get(part)
+            if any([submod.get(k, 0) for k in fe_losses_items]):
+                if submod.get('fillfac', 0):
+                    submod['fillfact'] = submod['fillfac']
+                fe_losses += self.__render(submod, 'FE-losses')
+                fe_losses.append('pre_models("FE-Losses-1")')
+
+        for part in ('rotor', 'commutator', 'magnet'):
             if model.get(part, 0):
                 submod = model.get(part)
-                if any(submod.get(k, 0) for k in (
-                        'ffactor', 'cw', 'ch', 'hyscoef',
-                        'edycof', 'indcof', 'fillfact',
-                        'fillfac','basfreq', 'basind',
-                        'ffactor')):
+                if any([submod.get(k, 0) for k in fe_losses_items]):
                     if submod.get('fillfac', 0):
                         submod['fillfact'] = submod['fillfac']
-                    return self.__render(submod, 'FE-losses')
-        return []
+                    fe_losses += self.__render(submod, 'FE-losses')
+                    fe_losses.append('pre_models("FE-Losses-2")')
+        return fe_losses
 
     def create_gen_winding(self, model):
         try:
             model.winding['wire'].update(
                 {"num_layers": model.winding["num_layers"]})
             genwdg = self.__render(model.winding,
-                                    'gen_' + model.winding['wire'].get('name'))
+                                   'gen_' + model.winding['wire'].get('name'))
         except:
             genwdg = self.__render(model, 'gen_winding')
 
@@ -677,7 +690,6 @@ class Builder:
                     self.create_connect_models(model) +
                     self.create_rotor_winding(model)) + \
                     self.create_thermal_properties(model)
-
         return (self.open_model(model) +
                 self.create_fe_losses(model) +
                 self.create_magnet(model, magnetMat))
@@ -738,6 +750,11 @@ class Builder:
                         if sim.get('airgap_induc', 0) else [])
         displ_stator_rotor = self.create_displ_stator_rotor(
             sim.get('eccentricity', {}))
+        # sliding band
+        sliding_band = []
+        if sim.get("sliding", 0):
+            sliding_band = [f'save_model("cont")',
+                            f'enable_sliding()']
         revert_displ = []
         if displ_stator_rotor:
             sim['eval_force'] = 1
@@ -757,6 +774,7 @@ class Builder:
                     sim.noload_ex_cur = sim.get('nload_ex_cur')
         felosses = custom_fefunc + self.create_fe_losses(sim)
         fslcalc = (displ_stator_rotor
+                   + sliding_band
                    + self.__render(sim, sim.get('calculationMode'))
                    + airgap_induc + revert_displ
                    + ['save_model("cont")'])

femagtools/isa7.py

@@ -1035,16 +1035,28 @@ class Isa7(object):
     def get_mass(self):
         """ return mass (in kg) of material conductors, iron, magnets
         """
+        masse_rotor_yoke = 0
+        section_rotor_yoke = 0
         try:
             return self.mass
         except AttributeError:
             self.mass = [{'iron': 0, 'conductors': 0, 'magnets': 0},
                          {'iron': 0, 'conductors': 0, 'magnets': 0}]
         scf = self.scale_factor()
+        for se in self.subregions:
+            if se.name == 'Bar':
+                r = 1 # as rotor bar is inside
+                spw = self.CU_SPEZ_WEIGHT*1e3
+                l = 1 #self.PS_LENGTH_CU[r]*1e-2
+                slf = 1 #self.PS_FILFACTOR_CU[r]
+                self.mass[r]['conductors'] += scf*se.area()*self.arm_length*spw*l*slf
         for se in self.superelements:
+            winding_detected=0
+            lamination_detected=0
             r = 0 if se.outside else 1
             if se.subregion:
                 if se.subregion.winding:
+                    winding_detected=1
                     spw = self.CU_SPEZ_WEIGHT*1e3
                     l = self.PS_LENGTH_CU[r]*1e-2
                     slf = self.PS_FILFACTOR_CU[r]
@@ -1052,6 +1064,7 @@ class Isa7(object):
                     continue
 
             if se.mcvtype or se.elements[0].is_lamination():
+                lamination_detected=1
                 try:
                     spw = self.iron_loss_coefficients[se.mcvtype-1][
                         'spec_weight']*1e3  # kg/m³
@@ -1062,6 +1075,9 @@ class Isa7(object):
                     fillfact = 1
                     #logger.warning('missing iron losscoeffs using defaults')
                 m = scf*self.arm_length*se.area()*spw*fillfact
+                if r == 1:
+                    masse_rotor_yoke += m
+                    section_rotor_yoke += se.area()
                 self.mass[r]['iron'] += m
             else:
                 try:

femagtools/job.py

@@ -76,12 +76,14 @@ class Task(object):
     def set_stateofproblem(self, stateofproblem):
         self.stateofproblem = stateofproblem
 
-    def add_file(self, fname, content=None):
+    def add_file(self, fname, content=None, append=False):
         """adds a file required by this task
 
         Args:
             fname: file name
-            content: list of str written to file if not None"""
+            content: list of str written to file if not None
+            append: append file mode if true
+        """
         base = os.path.basename(fname)
         self.transfer_files.append(fname)
         if os.path.splitext(base)[-1] == '.fsl':
@@ -94,7 +96,8 @@ class Task(object):
             return
 
         # this file has to be created
-        with open(os.path.join(self.directory, base), 'w') as f:
+        fmode = 'a' if append else 'w'
+        with open(os.path.join(self.directory, base), fmode) as f:
             f.writelines('\n'.join(content))
 
     def get_results(self):
@@ -143,6 +146,15 @@ class Task(object):
         result = dict(error=msg)
         return result
 
+    def read_nc(self):
+        "read most recent NC file and return result"
+        basedir = pathlib.Path(self.directory)
+        ncfiles = sorted(basedir.glob('*.nc'))
+        if not ncfiles:
+            return None
+        import femagtools.nc
+        return femagtools.nc.read(ncfiles[-1])
+
     def readErrorMessage(self, html=True):
         errstr = ""
         if html:

femagtools/machine/__init__.py

@@ -65,8 +65,8 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
             logger.warning(
                 "single temperature DQ parameters: unable to fit temperature %s", temp)
 
-        psid = rwdg*rlfe*dqp['psid']
-        psiq = rwdg*rlfe*dqp['psiq']
+        psid = rwdg*rlfe*np.array(dqp['psid'])
+        psiq = rwdg*rlfe*np.array(dqp['psiq'])
         losses = __scale_losses(dqp['losses'], rlfe)
         losses['ef'] = dqpars[-1]['losses'].get('ef', [2.0, 2.0])
         losses['hf'] = dqpars[-1]['losses'].get('hf', [1.0, 1.0])
@@ -82,7 +82,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
                 losses=losses,
                 id=np.array(dqp['id'])/rwdg,
                 iq=np.array(dqp['iq'])/rwdg,
-                tcu1=temp[0],
+                tcu1=temp[0], tmag=temp[1],
                 **opts)
         else:
             beta = dqp['beta']
@@ -96,7 +96,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
                 losses=losses,
                 beta=beta,
                 i1=i1,
-                tcu1=temp[0],
+                tcu1=temp[0], tmag=temp[1],
                 **opts)
         return machine
 
@@ -117,7 +117,6 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     pars.update(opts)
     return InductionMachine(pars)
 
-
 def create(bch, r1, ls, lfe=1, wdg=1):
     """create PmRelMachine from BCH
 
@@ -147,7 +146,8 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             if 'ex_current' in bch.machine:
                 raise ValueError("not yet implemented for EESM")
             machine = PmRelMachinePsidq(m, p, psid, psiq, r1*rlfe*rwdg**2,
-                                        id, iq, ls*rwdg**2, losses=losses)
+                                        id, iq, ls*rwdg**2, losses=losses,
+                                        tmag=bch.magnet.get('Tmag', 20))
             try:
                 machine.rotor_mass = rlfe*np.sum(bch.weights[1])
             except (IndexError, AttributeError):
@@ -172,7 +172,8 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             machine = PmRelMachineLdq(m, p, psid=psid, psiq=psiq,
                                       r1=r1*rlfe*rwdg**2,
                                       i1=i1, beta=beta, ls=ls*rwdg**2,
-                                      losses=losses)
+                                      losses=losses,
+                                      tmag=bch.magnet.get('Tmag', 20))
             try:
                 machine.rotor_mass = rlfe*np.sum(bch.weights[1])
             except (IndexError, AttributeError):

femagtools/machine/effloss.py

@@ -10,7 +10,7 @@ from . import create_from_eecpars
 logger = logging.getLogger("femagtools.effloss")
 
 
-def iqd_tmech_umax(m, u1, with_mtpa, progress, speed_torque, iq, id, iex):
+def iqd_tmech_umax(m, u1, with_mtpa, with_tmech, progress, speed_torque, iq, id, iex):
     """calculate iq, id for each load (n, T) from speed_torque at voltage u1
 
         Args:
@@ -25,9 +25,14 @@ def iqd_tmech_umax(m, u1, with_mtpa, progress, speed_torque, iq, id, iex):
     num_iv = round(nsamples/7)
     try:
         for i, nT in enumerate(speed_torque):
-            iqde = m.iqd_tmech_umax(
-                nT[1], 2*np.pi*nT[0]*m.p,
-                u1, with_mtpa=with_mtpa)[:-1]
+            if with_tmech:
+                iqde = m.iqd_tmech_umax(
+                    nT[1], 2*np.pi*nT[0]*m.p,
+                    u1, with_mtpa=with_mtpa)[:-1]
+            else:
+                iqde = m.iqd_torque_umax(
+                    nT[1], 2*np.pi*nT[0]*m.p,
+                    u1, with_mtpa=with_mtpa)[:-1]
             iq[i] = iqde[0]
             id[i] = iqde[1]
             if len(iqde) > 2:
@@ -39,7 +44,8 @@ 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, publish=0):
+def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa, with_tmech,
+                         publish=0):
     """calculate iqd for sm and pm using multiproc
     """
     progress_readers = []
@@ -59,7 +65,7 @@ def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa, publish=0):
             iex.append(multiprocessing.Array('d', chunksize))
             iexk = iex[k]
         p = multiprocessing.Process(target=iqd_tmech_umax,
-                                    args=(m, u1, with_mtpa,
+                                    args=(m, u1, with_mtpa, with_tmech,
                                           prog_writer,
                                           ntmesh.T[i:i+chunksize],
                                           iq[k], id[k], iexk))
@@ -254,14 +260,26 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
                                     rb['n'], rb['T'], npoints)
     else:
         nt = []
-        iq, id = m.iqd_torque(T[-1])
+        if isinstance(m, (SynchronousMachineLdq, SynchronousMachinePsidq)):
+            iq, id, iex = m.iqd_torque(T[-1])
+            i1max = betai1(iq, id)[1]
+            w1type, tmax = m.w1_imax_umax(i1max, u1) 
+            pmax = tmax*w1type/m.p
+        else:
+            iq, id = m.iqd_torque(T[-1])
+
         i1max = betai1(iq, id)[1]
         logger.info("%s %s", n, T)
         for nx in n:
             w1 = 2*np.pi*nx*m.p
-            iq, id, tq =  m.iqd_imax_umax(i1max, w1, u1, T[-1],
-                                          with_tmech=with_tmech,
-                                          with_mtpa=with_mtpa)
+            if isinstance(m, (SynchronousMachineLdq, SynchronousMachinePsidq)):
+                tq = T[-1]
+                if tq*w1/m.p > pmax: 
+                    tq = pmax/w1*m.p
+            else:
+                iq, id, tq =  m.iqd_imax_umax(i1max, w1, u1, T[-1],
+                                            with_tmech=with_tmech,
+                                            with_mtpa=with_mtpa)
             if np.isclose(tq, T[-1]):
                 tq = T[-1]
             for Tx in T:
@@ -271,12 +289,12 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
             raise ValueError("Speed, Torque Mesh is empty")
         nsamples = len(n)
         ntmesh = np.array(nt).T
-
     logger.info("total speed,torque samples %s", ntmesh.shape)
     if isinstance(m, (PmRelMachine, SynchronousMachine)):
         if num_proc > 1:
             iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa,
-                                       publish=progress)
+                                       with_tmech, publish=progress)
+
         else:
             class ProgressLogger:
                 def __init__(self, nsamples, publish):
@@ -353,8 +371,13 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plfe2 = m.kpfe*m.iqd_plfe2(*iqd, f1)
         plmag = np.zeros_like(plfe2)
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], 2*np.pi*f1)
-        plcu1_dc = [] # reserved for winding (dc, ac) losses
-        plcu1_ac = []
+        try:
+            plcu1_dc = m.iqd_plcu1(iqd[0], iqd[1],
+                                np.array([0.0 for i in f1])).tolist()
+            plcu1_ac = [i-j for i, j in zip(plcu1.tolist(), plcu1_dc)]
+        except:
+            plcu1_dc, plcu1_ac = [], []
+
         plcu2 = m.iqd_plcu2(*iqd)
         tfric = m.tfric
         logger.info("Iex %f %f",

femagtools/machine/im.py

@@ -521,9 +521,10 @@ class InductionMachine(Component):
             wmrange = sorted([0, wmType, wmPullout, wmMax])
         elif wmMax < wmType:
             wmrange = sorted([0, wmMax])
+        elif wmType<0 or wmPullout<0 or wmMax<0:
+            wmrange = sorted([1, abs(min(wmMax,wmType, wmPullout)), abs(max(wmMax,wmType, wmPullout))])
         else:
             wmrange = sorted([0, wmType, wmMax])
-
         logger.info("Speed range %s", wmrange)
         wmlin = []
         dw = 0
@@ -679,11 +680,11 @@ def parident(workdir, engine, f1, u1, wdgcon,
         m[wdgk].pop('resistance')
     except KeyError:
         pass
-
+    
     parstudy = femagtools.parstudy.ParameterStudy(
         workdir, condMat=condMat,
         magnetizingCurves=magnetizingCurves, cmd=cmd)
-
+    
     builder = femagtools.fsl.Builder(kwargs.get('templatedirs', []))
     model = femagtools.model.MachineModel(m)
     # modelfiles = parstudy.setup_model(builder, model)
@@ -756,7 +757,8 @@ def parident(workdir, engine, f1, u1, wdgcon,
     barmodel = femagtools.model.MachineModel(rotorbar)
     extra_result_files = ['bar.dat']
     r = (da1-ag)/2
-    task = job.add_task(_eval_ecsim())
+    #task = job.add_task(_eval_ecsim())
+    task = job.add_task(_eval_ecsim(), extra_result_files)
     logger.debug("Task %s rotobar workdir %s result files %s",
                  task.id, task.directory, task.extra_result_files)
     task.set_stateofproblem('mag_dynamic')
@@ -793,7 +795,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
     logger.info('Started %s', status)
     status = engine.join()
     tend = time.time()
-    logger.info("Elapsed time %d s Status %s",
+    logger.info("Elapssed time %d s Status %s",
                 (tend-tstart), status)
     if any([x != 'C' for x in status]):
         raise ValueError("AC simulation failed")
@@ -818,16 +820,17 @@ def parident(workdir, engine, f1, u1, wdgcon,
     u1ref = u1ph
     psiref = u1ref/w1
 
-    # def inoload(x, iml, ims, mexp):
-    #    """return noload current"""
-    #    return iml*x/psiref + ims*(x/psiref)**mexp
-    # fitp, cov = so.curve_fit(inoload, psihtab, i10tab, (1, 1, 1))
-    # iml, ims, mexp = fitp
-    # logger.info("iml, ims, mexp %g, %g, %g",
-    #            iml, ims, mexp)
-    # i1tab.insert(0, 0)
-    # psi1_0.insert(0, 0)
-    # i1_0.insert(0, 0)
+  # def inoload(x, iml, ims, mexp):
+  #    """return noload current"""
+  #    return iml*x/psiref + ims*(x/psiref)**mexp
+  # fitp, cov = so.curve_fit(inoload, psihtab, i10tab, (1, 1, 1))
+  # iml, ims, mexp = fitp
+  # logger.info("iml, ims, mexp %g, %g, %g",
+  #            iml, ims, mexp)
+  # i1tab.insert(0, 0)
+  # psi1_0.insert(0, 0)
+  # i1_0.insert(0, 0)
+
     logger.info("psi1_0 %s", np.mean(psi1_0, axis=1))
     logger.info("psih %s", psih)
     logger.debug("psi1_0-psih %s", np.mean(psi1_0, axis=1)-psih)
@@ -848,7 +851,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
             hs = machine['stator'][slotmodel].get('slot_height',
                                                   0.33*(machine['outer_diam']-da1))
         n = machine[wdgk]['num_wires']
-        if 'dia_wire' in machine[wdgk]:
+        if 'dia_wire' in machine[wdgk] and machine[wdgk].get('dia_wire', 1e-3) !=0:
             aw = np.pi*machine[wdgk].get('dia_wire', 1e-3)**2/4
         else:  # wire diameter from slot area
             aw = 0.75 * \
@@ -875,6 +878,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
     #                             kind='quadratic')(imref))
     psihref = float(log_interp1d(i1tab, psih)(imref))
     psi1ref = float(psi1(imref))
+  
 
     lh = psihref/imref
     L1 = psi1ref/imref
@@ -905,8 +909,37 @@ def parident(workdir, engine, f1, u1, wdgcon,
     # r2 = results[1]['r2']
     # ls2 = results[1]['ls2']
     pfe = results[2]['pfe1'][0]
+
+    end_ring_section = machine['rotor']['Aring']
+    bore_diam = machine['bore_diam']
+    for key, value in machine['rotor'].items():
+        if isinstance(value, dict) and 'slot_height' in value:
+            slot_height_rotor = value['slot_height']
+            break
+    if slot_height_rotor is not None:
+        rayon = (bore_diam / 2) - slot_height_rotor/2
+        end_ring_length = 2 * np.pi * rayon
+    else:
+        end_ring_length = 0
+
+    end_ring_volume = end_ring_section*end_ring_length
+
+    for material_info in condMat:
+        if material_info.get('name') == machine.get('rotor', {}).get('material'):
+            spmaweight_rotor = material_info.get('spmaweight')
+            break
+        else:
+            spmaweight_rotor = 0
+    end_ring_mass = end_ring_volume * spmaweight_rotor*1e3
+
     rotor_mass = sum([results[2].get('conweight', 0),
                       results[2].get('lamweight', 0)])
+    logger.info('Conductor mass in rotor = %s',results[2].get('conweight', 0))
+    logger.info('Lamination mass in rotor = %s',results[2].get('lamweight', 0))
+    logger.info('Rotor mass without end-ring = %s',rotor_mass)
+    rotor_mass += 2*end_ring_mass
+    logger.info('One end-ring mass = %s',end_ring_mass)
+    logger.info('Total rotor mass = %s',rotor_mass)
 
     n = machine[wdgk]['num_wires']
     g = loadsim['num_par_wdgs']
@@ -974,12 +1007,13 @@ class _eval_noloadrot():
         i0 = np.linalg.norm(
             femagtools.machine.T(0).dot(ire.T),
             axis=0)/np.sqrt(2)
+        
 
         psi0 = np.array([np.linalg.norm(
             femagtools.machine.T(0).dot(psire[:, k, :].T),
             axis=0)/np.sqrt(2)
             for k in range(ncurs)])
-
+        
         # matrix (i x j x k) of curr, rotor pos, angle
         Bamp = [[femagtools.airgap.fft(bags[:, 0], b, self.pmod)['Bamp']
                  for b in bags.T[1:]]