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

femagtools/__init__.py

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

femagtools/bch.py

@@ -115,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
@@ -1058,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):
@@ -1396,8 +1415,8 @@ class Reader:
                 pass
 
             try:
-                self.dqPar['psid'] = np.cos(gamma)*emf/w1
-                self.dqPar['psiq'] = -np.sin(gamma)*emf/w1
+                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]]
@@ -1405,6 +1424,8 @@ class Reader:
                                           self.dqPar['i1'][-1]]
                 except KeyError:
                     pass
+
+            self.dqPar = _convert(self.dqPar)
             return  # end of first section
 
         # second DQ-Parameter section
@@ -1476,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
@@ -1845,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/femag.py

@@ -485,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

@@ -287,20 +287,12 @@ class Builder:
             if 'dxf' in rotmodel:
                 return mcv + ['ndt(agndst)'] + rotmodel['dxf']['fsl']
             templ = 'rot_hsm'
-        if templ == 'rotorKs2':
-            if 'dxf' in rotmodel:
-                return mcv + ['ndt(agndst)'] + rotmodel['dxf']['fsl']
-            templ = 'rotorKs2'
         rotmodel.update(model.rotor[templ])
         return mcv + culosses + self.render_rotor(rotmodel, templ)
 
     def create_rotor_winding(self, model):
-        if 'ecSimulation' in model.stator:
-            return self.render_rotor(model.rotor, 'rotor_winding_ks2_ecSimulation')
         if hasattr(model, 'rotor') and model.rotortype() == 'EESM':
             return self.render_rotor(model.rotor, 'rotor_winding')
-        if hasattr(model, 'rotor') and model.rotortype() == 'rotorKs2':
-            return self.render_rotor(model.rotor, 'rotor_winding_ks2')
         return []
 
     def prepare_magnet(self, model):
@@ -444,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')
 
@@ -514,11 +519,8 @@ class Builder:
         params['nodedist'] = fmt.get('nodedist', 1)
         params['full_model'] = fmt.get('full_model', False)
         params['EESM'] = fmt.get('type', 'PMSM') == 'EESM'
-        params['rotorKs2'] = fmt.get('type', 'PMSM') == 'rotorKs2'
         if params['EESM']:
             model.rotor['EESM'] = {}
-        if params['rotorKs2']:
-            model.rotor['rotorKs2'] = {}
         conv = convert(fname, **params)
 
         model.set_value('poles', conv.get('num_poles'))
@@ -561,8 +563,6 @@ class Builder:
         if not (hasattr(model, 'magnet') or hasattr(model, 'rotor')):
             if params['EESM']:
                 setattr(model, 'rotor', {})
-            elif params['rotorKs2']:
-                setattr(model, 'rotor', {})
             else:
                 setattr(model, 'magnet', {})
 
@@ -672,20 +672,14 @@ class Builder:
                         self.mesh_airgap(model) +
                         self.create_connect_models(model) +
                         self.create_rotor_winding(model))
-            if 'statorRing' in model.stator and 'ecSimulation' not in model.stator:
-                return (self.create_new_model(model) +
-                        self.create_cu_losses(windings, condMat, ignore_material) +
-                        self.create_fe_losses(model) +
-                        rotor +
-                        self.create_stator_model(model) +
-                        self.create_rotor_winding(model))
-            if 'ecSimulation' in model.stator:
+            if 'statorRing' in model.stator:
                 return (self.create_new_model(model) +
                         self.create_cu_losses(windings, condMat, ignore_material) +
                         self.create_fe_losses(model) +
                         rotor +
                         self.create_stator_model(model) +
                         self.create_rotor_winding(model))
+
             return (self.create_new_model(model) +
                     self.create_cu_losses(windings, condMat, ignore_material) +
                     self.create_fe_losses(model) +
@@ -696,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))
@@ -757,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
@@ -776,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")'])
@@ -789,12 +788,6 @@ class Builder:
         else:
             plots = []
 
-        if sim.get('calculationMode') in ('cogg_calc',
-                                          'ld_lq_fast',
-                                          'pm_sym_loss',
-                                          'torq_calc',
-                                          'psd_psq_fast'):
-            return felosses + fslcalc + self.__render(sim, 'plots')
         return felosses + fslcalc + plots
 
     def create_shortcircuit(self, model):
@@ -883,6 +876,7 @@ class Builder:
                 self.fsl_stator = True
             if magnet:
                 self.fsl_rotor = True
+
         return template.render_unicode(model=model).split('\n')
 
     def render_template(self, content_template, parameters):

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

@@ -146,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

@@ -38,6 +38,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
         opts['rotor_mass'] = rlfe*eecpars['rotor_mass']
     except KeyError:
         pass
+
     if 'ldq' in eecpars or 'psidq' in eecpars:  # this is a PM (or EESM)
         try:
             dqpars = eecpars['ldq']
@@ -81,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']
@@ -95,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
 
@@ -113,40 +114,6 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     pars['psi'] = [psi*rwdg*rlfe for psi in pars['psi']]
     pars['tcu1'] = temp[0]
     pars['tcu2'] = temp[1]
-
-    pars.update(opts)
-    return InductionMachine(pars)
-    
-
-def create_from_eecpars_im(temp, eecpars, lfe=1, wdg=1):
-    rlfe = lfe
-    rwdg = wdg
-
-    eecpars_new=eecpars['opResults']
-    opts = {k: eecpars_new[k] for k in ('zeta1', 'gam', 'kh', 'kpfe',
-                                    'kfric_b', 'kpmag') if k in eecpars_new}
-
-    pars = copy.deepcopy(eecpars_new)
-
-    pars['r1'] = rlfe*rwdg**2*pars.get('r1', 0)
-    pars['lsigma1'] = rlfe*pars['lsigma1']
-    pars['lsigma2'] = rlfe*pars['lsigma2']
-    pars['psiref'] = rwdg*rlfe*pars['psiref']
-    pars['u1ref'] = rwdg*rlfe*pars['u1ref']
-    pars['r2'] = rlfe*pars['r2']
-    pars['fec'] = rlfe*pars['fec']
-    pars['fee'] = rlfe*pars['fee']
-    pars['im'] = [im/rwdg for im in pars['im']]
-    pars['psi'] = [psi*rwdg*rlfe for psi in pars['psi']]
-    pars['tcu1'] = temp[0]
-    pars['tcu2'] = temp[1]
-    pars['nmax'] = eecpars['op']['nmax']
-    pars['umax'] = eecpars['op']['umax']
-    #pars['u1'] = eecpars['genDesign']['u1']
-    pars['Tmax'] = eecpars['op']['Tmax']
-    pars['p'] = eecpars['genDesign']['p']
-    pars['m'] = eecpars['genDesign']['m']
-
     pars.update(opts)
     return InductionMachine(pars)
 
@@ -179,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):
@@ -204,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

@@ -262,6 +262,9 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         nt = []
         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])
 
@@ -270,12 +273,9 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         for nx in n:
             w1 = 2*np.pi*nx*m.p
             if isinstance(m, (SynchronousMachineLdq, SynchronousMachinePsidq)):
-                if with_tmech:
-                    iq, id, iex, tq = m.iqd_tmech_umax(
-                        T[-1], w1, u1)
-                else:
-                    iq, id, iex, tq = m.iqd_torque_umax(
-                        T[-1], w1, u1)
+                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,
@@ -289,7 +289,6 @@ 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:

femagtools/machine/im.py

@@ -119,7 +119,6 @@ class InductionMachine(Component):
         if 'u1type' in parameters:
             self.u1ref = self.u1type
         if hasattr(self, 'f1ref'):
-            #self.wref = 2*np.pi*self.f1ref[0]
             self.wref = 2*np.pi*self.f1ref
             if hasattr(self, 'u1ref'):
                 self.psiref = self.u1ref/self.wref
@@ -522,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
@@ -604,6 +604,7 @@ class InductionMachine(Component):
                 r['eta'] += (pmech[i:]/(p1[i:])).tolist()
             else:
                 r['eta'] += (p1[i:]/pmech[i:]).tolist()
+
         return r
 
 
@@ -660,7 +661,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
                                       num_steps)]
     else:
         i1tab = np.linspace(i1min, i1max, num_steps).tolist()
-        
+
     m = copy.deepcopy(machine)
     Q2 = m['rotor']['num_slots']
     noloadsim = dict(
@@ -668,7 +669,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
         curvec=i1tab,
         num_par_wdgs=machine[wdgk].get('num_par_wdgs', 1),
         Q2=Q2)
-    
+
     da1 = m['bore_diam']
     ag = m['airgap']
     # do not create airgap nodechains automatically
@@ -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)
@@ -722,7 +723,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
             rotorbar['rotor'][k]['num_slots_gen'] = 1
             rotorbar['rotor'][k]['zeroangle'] = 90-180/Q2
             break
-      
+
     loadsim = dict(  # not used
         calculationMode="asyn_motor",
         bar_len=bar_len,
@@ -740,7 +741,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
     task = job.add_task(_eval_noloadrot(pmod), extra_result_files)
     logger.debug("Task %s noload workdir %s result files %s",
                  task.id, task.directory, task.extra_result_files)
-    # create model 
+    # create model
     for mc in parstudy.femag.copy_magnetizing_curves(
             model,
             dir=task.directory):
@@ -754,11 +755,10 @@ def parident(workdir, engine, f1, u1, wdgcon,
 
     # ec simulation
     barmodel = femagtools.model.MachineModel(rotorbar)
-    barmodel_new = barmodel
-    barmodel_new['stator']['ecSimulation']=1
     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')
@@ -769,7 +769,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
         task.add_file(mc)
     task.add_file(
         'femag.fsl',
-        builder.create_model(barmodel_new,
+        builder.create_model(barmodel,
                              condMat=parstudy.femag.condMat) +
         builder.create_analysis(ecsim) +
         ['save_model("close")'])
@@ -795,10 +795,9 @@ 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]):
-        logger.error("AC simulation failed with statuses: %s", status)
         raise ValueError("AC simulation failed")
     # collect results
     results = [t.get_results() for t in job.tasks]
@@ -821,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)
@@ -851,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 * \
@@ -878,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
@@ -908,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']
@@ -977,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:]]

femagtools/machine/pm.py

@@ -92,7 +92,8 @@ class PmRelMachine(object):
         self.io = (1, -1)
         self.fo = 50.0
         self.tcu1 = 20
-        self.tmag = 20
+        # for information purpose only
+        self.tmag = kwargs.get('tmag', 20)
         self.zeta1 = 0.2
         self.gam = 0.7
         self.kh = 2