femagtools 1.8.14__tar.gz → 1.8.16__tar.gz

{femagtools-1.8.14/src/femagtools.egg-info → femagtools-1.8.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: femagtools
-Version: 1.8.14
+Version: 1.8.16
 Summary: Python API for FEMAG
 Author-email: Ronald Tanner <tar@semafor.ch>, Dapu Zhang <dzhang@gtisoft.com>, Beat Holm <hob@semafor.ch>, Günther Amsler <amg@semafor.ch>, Nicolas Mauchle <mau@semafor.ch>
 License: Copyright (c) 2016-2023, Semafor Informatik & Energie AG, Basel

{femagtools-1.8.14 → femagtools-1.8.16}/src/femagtools/__init__.py

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

{femagtools-1.8.14 → femagtools-1.8.16}/src/femagtools/bch.py

@@ -420,6 +420,11 @@ class Reader:
             self.windings[w[0]]['N'].append(w[2])
             self.windings[w[0]]['R'].append(w[3]/1e3)
             self.windings[w[0]]['PHI'].append(w[4])
+        # check if external rotor
+        if hasattr(self, "machine"): 
+            if "fc_radius" in self.machine:
+                if np.mean(self.windings[1]["R"]) < self.machine["fc_radius"]:
+                    self.external_rotor = True
 
     def __read_winding_factors(self, content):
         "read winding factors section"
@@ -1202,10 +1207,7 @@ class Reader:
         m = []
         subregs = [name.split()[-1]
                    for name in content[2].split('\t') if name][2:]
-        # outer rotor motor
-        if 'Iron' in subregs and \
-            'Rotor' in subregs:
-            self.external_rotor = True
+
         logger.info("Stator Subregions: %s", subregs)
         speed = float(content[0].split()[-1])/60.
         logger.info('losses for speed %f', speed)

{femagtools-1.8.14 → femagtools-1.8.16}/src/femagtools/femag.py

@@ -153,7 +153,7 @@ class BaseFemag(object):
         dest = dir if dir else self.workdir
         if isinstance(feloss, (int, float)):
             try:
-                feloss = {1: 'jordan', 11: 'bertotti'}[int(feloss)]
+                feloss = {1: 'jordan', 2: "steinmetz", 10:"modified steinmetz", 11: 'bertotti'}[int(feloss)]
             except KeyError:
                 feloss = ''
         return [self.magnetizingCurves.writefile(m[0], dest,
@@ -188,6 +188,11 @@ class BaseFemag(object):
             recsin = simulation.get('recsin', '')
             feloss = simulation.get('calc_fe_loss', '')
         self.copy_magnetizing_curves(self.model, recsin=recsin, feloss=feloss)
+
+        if feloss and \
+            int(feloss) in (1, 2):
+            simulation["calc_fe_loss"] = 1
+
         try:
             if 'wdgdef' in self.model.winding:
                 self.model.winding['wdgfile'] = self.create_wdg_def(

{femagtools-1.8.14 → femagtools-1.8.16}/src/femagtools/fsl.py

@@ -23,6 +23,15 @@ def cosys(model):
         return 'cosys("polar")'
     return 'cosys("cartes")'
 
+class MaterialCollection:
+    def __init__(self, materials):
+        self.materials = materials
+
+    def find(self, name):
+        for mat in self.materials:
+            if mat['name'] == name:
+                return mat
+        return None
 
 class Builder:
     def __init__(self, templatedirs=[]):
@@ -922,4 +931,4 @@ class Builder:
             content='\n'.join(content),
             type='fsl',
             content_template='\n'.join(content_template),
-            parameter=parameter)
+            parameter=parameter)

{femagtools-1.8.14 → femagtools-1.8.16}/src/femagtools/isa7.py

@@ -921,7 +921,7 @@ class Isa7(object):
                 else:
                     flx_fac = 1
             el_fe_ind = [np.array(reader.el_fe_induction_1).T/flx_fac,
-                        np.array(reader.el_fe_induction_2).T/flx_fac]
+                         np.array(reader.el_fe_induction_2).T/flx_fac]
             eddy_cu_vpot = np.array(reader.eddy_cu_vpot).T/1000
             if len(el_fe_ind[0].shape) == 4:
                 pdim = self.pos_el_fe_induction.shape[0]
@@ -1051,12 +1051,9 @@ class Isa7(object):
                 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]
@@ -1064,7 +1061,6 @@ 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³
@@ -1096,7 +1092,8 @@ class Isa7(object):
 
         """
         return [sr.name for sr in self.subregions
-                if sr.superelements[0].mcvtype or sr.superelements[0].elements[0].is_lamination()]
+                if (sr.superelements[0].mcvtype or
+                    sr.superelements[0].elements[0].is_lamination())]
 
     def _axis_ratio(self, apos, br, bt):
         from .utils import fft
@@ -1399,6 +1396,23 @@ class Isa7(object):
             bxy.append(Trot(-theta).dot((fd['bx'], fd['by'])))
         return transform_flux_density(se.alpha, np.array(bxy))
 
+    def lamination_border(self):
+        """return xy coordinates of lamination border nodes"""
+        bnodes = []
+        for sr in self.get_iron_subregions():
+            #bnodes += self.get_subregion(sr).border_node_keys()
+            bnodes += self.get_subregion(sr).nonper_border_nodes()[1]
+        keys, unique_counts = np.unique(bnodes, return_counts=True)
+
+        return np.array([self.nodes[k-1].xy
+                         for k, c in zip(keys, unique_counts) if c == 1])
+
+    def punchdist(self):
+        """ return lamination elements with punching border distance"""
+        elam = [e for e in self.elements if e.is_lamination()]
+        bnodes = self.lamination_border()
+        return elam, np.array([e.punchdist(bnodes) for e in elam])
+
 class Point(object):
     def __init__(self, x, y):
         self.x = x
@@ -1495,7 +1509,8 @@ class Element(BaseEntity):
             [v.xy for v in vertices], axis=0)/len(vertices)
 
     def flux_density(self, cosys='cartes'):
-        """return flux density components of this element converted to cosys: cartes, cylind, polar"""
+        """return flux density components of this element converted
+        to cosys: cartes, cylind, polar"""
         ev = self.vertices
         b1, b2 = 0, 0
         if self.el_type == ElType.LinearTriangle:
@@ -1621,6 +1636,16 @@ class Element(BaseEntity):
         """return temperature of this element"""
         return sum([v.vpot[1] for v in self.vertices])/len(self.vertices)
 
+    def punchdist(self, bnodes):
+        """return dist to punching border"""
+        try:
+            if self.is_lamination():
+                return np.min(np.linalg.norm(bnodes-self.center,
+                              axis=1))
+        except AttributeError:
+            pass
+        return np.nan
+
 
 class SuperElement(BaseEntity):
     def __init__(self, key, sr_key, elements, nodechains, color,
@@ -1704,6 +1729,7 @@ class SubRegion(BaseEntity):
         for se in superelements:
             se.subregion = self
         self.nodechains = nodechains
+        self._border = []
 
     def elements(self):
         """return elements of this subregion"""
@@ -1716,6 +1742,12 @@ class SubRegion(BaseEntity):
         """return area of this subregion"""
         return sum([e.area for e in self.elements()])
 
+    def nonper_border_nodes(self):
+        """return border nodes with non-periodic boundary condition"""
+        return (np.array([n.xy for nc in self.nodechains
+                          for n in nc.nodes if n.pernod == 0]),
+                set([n.key for nc in self.nodechains
+                     for n in nc.nodes if n.pernod == 0]))
 
 class Winding(BaseEntity):
     def __init__(self, key, name, subregions, num_turns, cur_re, cur_im,

{femagtools-1.8.14 → femagtools-1.8.16}/src/femagtools/machine/afpm.py

@@ -213,6 +213,9 @@ def parident(workdir, engine, temp, machine,
     if np.isscalar(machine['magnet'][slotmodel]['rel_magn_width']):
         num_slices = kwargs.get('num_slices', 3)
         rmagw = num_slices*[machine['magnet'][slotmodel]['rel_magn_width']]
+    elif len(machine['magnet'][slotmodel]['rel_magn_width']) == 1: 
+            num_slices = kwargs.get('num_slices', 3)
+            rmagw = num_slices*machine['magnet'][slotmodel]['rel_magn_width']
     else:
         rmagw = machine['magnet'][slotmodel]['rel_magn_width']
         num_slices = len(rmagw)
@@ -543,13 +546,18 @@ def process(lfe, pole_width, machine, bch):
         nsegx = machine['magnet'].get('num_segments', 1)
         if type(nsegx) == int:
             nsegx = [nsegx]*len(bch)
+        elif len(nsegx) == 1 and len(nsegx) < len(bch): 
+            nsegx = nsegx*len(bch)
+        else: 
+            pass 
         for nx, b in zip(nsegx, bch):
             pm = b['losses'][0]['magnet_data']
             magloss = ecloss.MagnLoss(magnet_data=[pm])
             ml = magloss.calc_losses_ialh2(nsegx=nx)
-            b['losses'][-1][k] = ml[0]
+            b["losses"][-1].update({k: ml[0]})
     else:
         k = 'magnetJ'
+
     if len(pole_width) > 1:
         maglosses = _integrate1d(radius, scale_factor*np.array(
             [b['losses'][-1][k]/lz
@@ -1025,7 +1033,9 @@ class AFPM:
                     machine['magnet'][slotmodel]['rel_magn_width'])
         if np.isscalar(machine['magnet'][slotmodel]['rel_magn_width']):
             rmagw = num_slices*[machine['magnet'][slotmodel]['rel_magn_width']]
-        else:
+        elif len(machine['magnet'][slotmodel]['rel_magn_width']) == 1: 
+                rmagw = num_slices*machine['magnet'][slotmodel]['rel_magn_width']
+        else: 
             rmagw = machine['magnet'][slotmodel]['rel_magn_width']
             num_slices = len(rmagw)
 

{femagtools-1.8.14 → femagtools-1.8.16}/src/femagtools/machine/effloss.py

@@ -79,7 +79,11 @@ def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa, with_tmech,
     while progress_readers:
         for r in multiprocessing.connection.wait(progress_readers):
             try:
-                collected_msg.append(r.recv())
+                #collected_msg.append(r.recv())
+                ret = r.recv()
+                if isinstance(ret, Exception):
+                    raise ret
+                collected_msg.append(ret)
                 i += 1
             except EOFError:
                 progress_readers.remove(r)
@@ -263,10 +267,11 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         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) 
+            w1type, tmax = m.w1_imax_umax(i1max, u1)
             pmax = tmax*w1type/m.p
         else:
             iq, id = m.iqd_torque(T[-1])
+            w1type, tmax = m.w1_imax_umax(betai1(iq, id)[1], u1)
 
         i1max = betai1(iq, id)[1]
         logger.info("%s %s", n, T)
@@ -274,16 +279,19 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
             w1 = 2*np.pi*nx*m.p
             if isinstance(m, (SynchronousMachineLdq, SynchronousMachinePsidq)):
                 tq = T[-1]
-                if tq*w1/m.p > pmax: 
+                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 w1 <= w1type:
+                    tq = tmax
+                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:
-                if Tx <= tq:
+                if np.abs(Tx) <= tq:
                     nt.append((nx, Tx))
         if not nt:
             raise ValueError("Speed, Torque Mesh is empty")
@@ -339,7 +347,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     else:
         f1 = []
         u1max = u1
-        r = dict(u1=[], i1=[], plfe1=[], plcu1=[], plcu2=[])
+        r = dict(u1=[], i1=[], plfe1=[], plcu1=[], plcu2=[], plcu1_dc=[], plcu1_ac=[])
         for nx, tq in ntmesh.T:
             wm = 2*np.pi*nx
             w1 = m.w1(u1max, m.psiref, tq, wm)
@@ -352,7 +360,9 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
             i2 = m.i2(w1, m.psi, wm)
             r['plcu1'].append(m.m*np.abs(i1)**2*m.rstat(w1))
             r['plcu2'].append(m.m*np.abs(i2)**2*m.rrot(w1-m.p*wm))
-
+            plcu_dc = m.m*np.abs(i1)**2*m.rstat(0)
+            r['plcu1_dc'].append(plcu_dc)
+            r['plcu1_ac'].append(m.m*np.abs(i1)**2*m.rstat(w1)-plcu_dc)
     if isinstance(m, PmRelMachine):
         plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
         plfe2 = m.kpfe*m.iqd_plfe2(iqd[0], iqd[1], f1)
@@ -370,7 +380,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
         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 = m.iqd_plcu1(iqd[0], iqd[1], f1)
         try:
             plcu1_dc = m.iqd_plcu1(iqd[0], iqd[1],
                                 np.array([0.0 for i in f1])).tolist()
@@ -388,19 +398,22 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plmag = np.zeros(ntmesh.shape[1])
         plcu1 = np.array(r['plcu1'])
         plcu2 = np.array(r['plcu2'])
-        plcu1_dc = [] # reserved for winding (dc, ac) losses
-        plcu1_ac = []
+        plcu1_dc = r['plcu1_dc'] # [] # reserved for winding (dc, ac) losses
+        plcu1_ac = r['plcu1_ac'] #[]
         iqd = np.zeros(ntmesh.shape)
         u1 = np.array(r['u1'])
         i1 = np.array(r['i1'])
+
+
         try:
             if isinstance(eecpars, dict):
                 tfric = eecpars['kfric_b']*eecpars['rotor_mass']*30e-3/np.pi
+                if 'tfric' in eecpars: # to get the user setted value (possible in IM)
+                    tfric=eecpars['tfric']
             else:
                 tfric = m.tfric
         except KeyError:
             tfric = 0
-
     plfric = 2*np.pi*ntmesh[0]*tfric
     if not with_tmech:
         ntmesh[1] -= tfric
@@ -437,4 +450,4 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plfric=plfric.tolist(),
         losses=ploss.tolist(),
         plcu1_dc=plcu1_dc,
-        plcu1_ac=plcu1_ac)
+        plcu1_ac=plcu1_ac)

{femagtools-1.8.14 → femagtools-1.8.16}/src/femagtools/machine/im.py

@@ -198,7 +198,9 @@ class InductionMachine(Component):
 
     def lstat(self, w):
         """stator leakage inductance"""
-        return self.lsigma1
+        # we add end-winding inductance here
+        le_value = getattr(self, 'le', 0)
+        return self.lsigma1 + le_value
 
     def rrot(self, w):
         """rotor resistance"""
@@ -485,77 +487,81 @@ class InductionMachine(Component):
         """
         with_tmech = kwargs.get('with_tmech', True)
 
-        wmType = self.wmfweak(u1max, self.psiref, T, with_tmech)
-        pmmax = wmType*T
-        wmPullout = so.fsolve(
-            lambda wx: (kpo*self.pullouttorque(self.p *
-                        wx, u1max) - abs(pmmax/wx)),
-            wmType)[0]
-        wmtab0 = np.linspace(wmType, 3*wmPullout)
-        for wm, tq in zip(wmtab0, [pmmax/wx for wx in wmtab0]):
-            logger.debug("u1 %g psi %g tq %g wm %g",
-                         u1max, self.psiref, tq, wm)
-            try:
-                w1 = self.w1(u1max, self.psiref, tq, wm, with_tmech)
-            except ValueError:
-                wmPullout = wm
-                break
-        wmMax = max(1.5*wmPullout, 3*abs(pmmax/T))
-        if n:
-            wmMax = 2*np.pi*n
-        if wmMax > wmPullout:
-            wmtab0 = np.linspace(wmPullout, wmMax)
-            for wm, tq in zip(wmtab0, [pmmax/wx**2
-                                       for wx in wmtab0]):
+        if np.isscalar(T):
+            wmType = self.wmfweak(u1max, self.psiref, T, with_tmech)
+            logger.info(wmType)
+            pmmax = wmType*T
+            wmPullout = so.fsolve(
+                lambda wx: (kpo*self.pullouttorque(self.p *
+                            wx, u1max) - abs(pmmax/wx)),
+                wmType)[0]
+            wmtab0 = np.linspace(wmType, 3*wmPullout)
+            for wm, tq in zip(wmtab0, [pmmax/wx for wx in wmtab0]):
                 logger.debug("u1 %g psi %g tq %g wm %g",
-                             u1max, self.psiref, tq, wm)
+                            u1max, self.psiref, tq, wm)
                 try:
                     w1 = self.w1(u1max, self.psiref, tq, wm, with_tmech)
                 except ValueError:
-                    wmMax = wm
+                    wmPullout = wm
                     break
-
-        logger.info("wmtype %f wpo %f wmmax %f", wmType, wmPullout, wmMax)
-
-        if wmType < wmPullout < wmMax:
-            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
-        for i, nx in enumerate([round(nsamples*(w1-w0)/wmMax)
-                                for w1, w0 in zip(wmrange[1:],
-                                                  wmrange)]):
-            if nx == 1:
-                nx = 2
-            if nx > 0:
-                lw = np.linspace(wmrange[i]+dw, wmrange[i+1], nx)
-                dw = lw[-1] - lw[-2]
-                wmlin.append(lw)
-        if len(wmlin) > 1:
-            wmtab = np.concatenate(wmlin)
-        else:
-            wmtab = wmlin[1:]
-
-        def tload2(wm):
-            if wm < wmType and wm < wmPullout:
-                return T
-            if wm < wmPullout:
+            wmMax = max(1.5*wmPullout, 3*abs(pmmax/T))
+            if n:
+                wmMax = 2*np.pi*n
+            if wmMax > wmPullout:
+                wmtab0 = np.linspace(wmPullout, wmMax)
+                for wm, tq in zip(wmtab0, [pmmax/wx**2
+                                        for wx in wmtab0]):
+                    logger.debug("u1 %g psi %g tq %g wm %g",
+                                u1max, self.psiref, tq, wm)
+                    try:
+                        w1 = self.w1(u1max, self.psiref, tq, wm, with_tmech)
+                    except ValueError:
+                        wmMax = wm
+                        break
+
+            logger.info("wmtype %f wpo %f wmmax %f", wmType, wmPullout, wmMax)
+
+            if wmType < wmPullout < wmMax:
+                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
+            for i, nx in enumerate([round(nsamples*(w1-w0)/wmMax)
+                                    for w1, w0 in zip(wmrange[1:],
+                                                    wmrange)]):
+                if nx == 1:
+                    nx = 2
+                if nx > 0:
+                    lw = np.linspace(wmrange[i]+dw, wmrange[i+1], nx)
+                    dw = lw[-1] - lw[-2]
+                    wmlin.append(lw)
+            if len(wmlin) > 1:
+                wmtab = np.concatenate(wmlin)
+            else:
+                wmtab = wmlin[1:]
+
+            def tload2(wm):
+                if wm < wmType and wm < wmPullout:
+                    return T
+                if wm < wmPullout:
+                    if pmmax < 0:
+                        return max(T, pmmax/wm)
+                    return min(T, pmmax/wm)
                 if pmmax < 0:
-                    return max(T, pmmax/wm)
-                return min(T, pmmax/wm)
-            if pmmax < 0:
-                return max(wmPullout*pmmax/wm**2, T)
-            return min(wmPullout*pmmax/wm**2, T)
+                    return max(wmPullout*pmmax/wm**2, T)
+                return min(wmPullout*pmmax/wm**2, T)
 
+            T = [tload2(wx) for wx in wmtab]
+        else:
+            wmtab = n
         r = dict(u1=[], i1=[], T=[], cosphi=[], n=[], s=[], sk=[],
-                 plfe1=[], plcu1=[], plcu2=[], f1=[])
-        T = [tload2(wx) for wx in wmtab]
+                    plfe1=[], plcu1=[], plcu2=[], f1=[])
         tfric = self.tfric
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -582,7 +588,8 @@ class InductionMachine(Component):
                 r['s'].append(float((w1 - self.p * wm) / w1))
                 r['sk'].append(self.sk(w1, np.abs(u1)/w1))
                 # add n_type to result dict
-                r['n_type'] = wmType/2/np.pi
+                if np.isscalar(T):
+                    r['n_type'] = wmType/2/np.pi
                 #            except ValueError as ex:
                 #                break
         r['plfw'] = [self.pfric(n) for n in r['n']]
@@ -863,9 +870,11 @@ def parident(workdir, engine, f1, u1, wdgcon,
         # TODO: sigma = 58e6
         # if 'material' in machine[wdgk]:
         #    sigma = condMat[machine[wdgk]]['elconduct']
+        if 'material' in m['windings']:
+            sigma = m['windings']['cuconduct']
         g = loadsim['num_par_wdgs']
         r1 = wdg_resistance(
-            wdg, n, g, aw, da1, hs, lfe)
+            wdg, n, g, aw, da1, hs, lfe, sigma=sigma)
 
     # psi1 = ip.interp1d(i1_0, np.mean(psi1_0, axis=1),
     #                    kind='quadratic')
@@ -910,7 +919,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
     # ls2 = results[1]['ls2']
     pfe = results[2]['pfe1'][0]
 
-    end_ring_section = machine['rotor']['Aring']
+    end_ring_section = machine['rotor'].get('Aring', 0)
     bore_diam = machine['bore_diam']
     for key, value in machine['rotor'].items():
         if isinstance(value, dict) and 'slot_height' in value:
@@ -957,12 +966,15 @@ def parident(workdir, engine, f1, u1, wdgcon,
         wmat = machine[wdgk]['material']
         impars['kth1'] = parstudy.femag.condMat.find(wmat)['tempcoef']
     except KeyError:
-        logger.warning('Missing winding material id')
+        logger.warning('Missing winding material id for stator')
+        for mat in condMat:
+            if mat['name'] == 'Cu': #as Copper is used as default (cf r1 and wdg_resistance)
+                impars['kth1'] = mat['tempcoef']
     try:
         bmat = machine['rotor']['material']
         impars['kth2'] = parstudy.femag.condMat.find(bmat)['tempcoef']
     except KeyError:
-        logger.warning('Missing winding material id')
+        logger.warning('Missing winding material id for rotor')
 
     return impars