femagtools 1.8.15__tar.gz → 1.8.17__tar.gz

{femagtools-1.8.15/src/femagtools.egg-info → femagtools-1.8.17}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: femagtools
-Version: 1.8.15
+Version: 1.8.17
 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.15 → femagtools-1.8.17}/src/femagtools/__init__.py

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

{femagtools-1.8.15 → femagtools-1.8.17}/src/femagtools/dxfsl/area.py

@@ -958,6 +958,23 @@ class Area(object):
             return False
         return True
 
+    def is_line_inside(self, p1, p2):
+        if self.is_point_inside(p1):
+            if self.is_point_inside(p2):
+                logger.debug("Border: Type of area %s is %s",
+                             self.identifier(), self.type)
+                return True
+            if self.the_point_is_inside_area(p2):
+                logger.debug("Inside: Type of area %s is %s",
+                             self.identifier(), self.type)
+                return True
+        elif self.is_point_inside(p2):
+            if self.the_point_is_inside_area(p1):
+                logger.debug("Inside: Type of area %s is %s",
+                             self.identifier(), self.type)
+                return True
+        return False
+
     def get_best_point_inside(self, geom):
         px1 = self.min_x - 5
         px2 = self.max_x + 5

{femagtools-1.8.15 → femagtools-1.8.17}/src/femagtools/dxfsl/converter.py

@@ -202,6 +202,18 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
                   title="Rotor Magnet Slice after Rebuild")
 
     rebuild = False
+    if machine_temp.magnets_missing(EESM):
+        mag = machine_temp.looking_for_one_possible_magnet()
+        if mag:
+            if machine.is_mirrored():
+                rebuild = machine_temp.create_mirror_lines_outside_magnets()
+                if machine_temp.create_auxiliary_lines():
+                    rebuild = True
+                if rebuild:
+                    machine_temp.rebuild_subregions(EESM, single=single)
+                    machine_temp.geom.force_area_as_magnet(mag)
+            return machine_temp
+
     if machine_temp.has_magnets_in_the_middle():
         logger.debug("Magnets cut")
         rebuild = machine_temp.create_mirror_lines_outside_magnets()
@@ -432,10 +444,10 @@ def convert(dxfile,
             return dict(error='unknown location {}'.format(part[1]))
     else:
         if da:
-            logger.warn("distance airgap (da) ignored")
+            logger.warning("distance airgap (da) ignored")
             da = 0.0
         if dy:
-            logger.warn("distance yoke (dy) ignored")
+            logger.warning("distance yoke (dy) ignored")
             dy = 0.0
 
     split_ini = split
@@ -1064,7 +1076,7 @@ def create_femag_parameters_stator(motor, position):
         params['da1'] = 2*motor.geom.min_radius
     params['slot_area'] = motor.slot_area()
     params['stator'] = _create_stator_parameters(motor)
-    params['machine'] = motor
+    #params['machine'] = motor
     return params
 
 
@@ -1080,5 +1092,5 @@ def create_femag_parameters_rotor(motor, position):
         params['da1'] = 2*motor.geom.min_radius
     params['slot_area'] = motor.slot_area()
     params['rotor'] = _create_rotor_parameters(motor)
-    params['machine'] = motor
+    #params['machine'] = motor
     return params

{femagtools-1.8.15 → femagtools-1.8.17}/src/femagtools/dxfsl/fslrenderer.py

@@ -270,7 +270,7 @@ class FslRenderer(object):
         for area in geom.list_of_areas():
             if area.number_of_elements() > 1:
                 p = area.get_point_inside(geom)
-                if p:
+                if p and area.type > 0:
                     self.content.append("x0, y0 = {}, {}".format(p[0], p[1]))
                     # self.content.append("point(x0, y0, red, 4)")  # for debugging
                     self.content.append("create_mesh_se(x0, y0)")
@@ -324,7 +324,7 @@ class FslRenderer(object):
                         self.content.append(
                             'x0_shaft, y0_shaft = x0, y0')
 
-                self.content.append("\n")
+        self.content.append("create_mesh(x0, y0)\n")
 
         txt = ["if x0_iron_yoke > 0.0 then",
                "  if mcvkey_yoke ~= 'dummy' then",

{femagtools-1.8.15 → femagtools-1.8.17}/src/femagtools/dxfsl/geom.py

@@ -2612,6 +2612,7 @@ class Geometry(object):
             areas_inside = [a for a in self.area_list
                             if area.is_inside(a, self)]
             if not areas_inside:
+                area.areas_inside = {}
                 continue
 
             areas_notouch = {a.identifier(): a for a in areas_inside
@@ -3748,6 +3749,41 @@ class Geometry(object):
 
         logger.debug("end of search_unknown_subregions")
 
+    def possible_magnet_in_the_middle(self, midangle):
+        self.set_areas_inside_for_all_areas()
+        mags = []
+        for n, a in enumerate(self.list_of_areas()):
+            if a.areas_inside:
+                continue
+            if a.close_to_startangle or a.close_to_endangle:
+                continue
+            if np.isclose(a.min_dist, self.min_radius):
+                continue
+            if np.isclose(a.max_dist, self.max_radius):
+                continue
+
+            a_midangle = a.get_mid_angle(self.center)
+            if np.isclose(midangle, a_midangle, atol=1e-2, rtol=1e-2):
+                s = a.area_size()
+                mags.append([s, n, a])
+
+        if not mags:
+            return False
+        mags.sort(reverse=True)
+        s, n, a = mags[0]
+        a.set_type(AREA.TYPE_MAGNET_AIRGAP)
+        a.phi = midangle
+        a.mag_width = (a.max_dist - a.min_dist) * 0.9
+        return a
+
+    def force_area_as_magnet(self, area):
+        for a in self.list_of_areas():
+            if a.is_equal(area, 1e-2):
+                a.set_type(area.type)
+                a.phi = area.phi
+                a.mag_width = area.mag_width
+                return
+
     def magnets_in_the_middle(self, midangle):
         mag_areas = [a for a in self.list_of_areas()
                      if a.is_magnet()]
@@ -4188,28 +4224,11 @@ class Geometry(object):
                         return True
         return False
 
-    def _line_inside_magnets(self, p1, p2):
-        for area in self.list_of_areas():
-            if area.is_magnet():
-                if area.is_point_inside(p1):
-                    if area.is_point_inside(p2):
-                        return True
-        return False
-
-    def _line_inside_air(self, p1, p2):
-        for area in self.list_of_areas():
-            if area.is_air():
-                if area.is_point_inside(p1):
-                    if area.is_point_inside(p2):
-                        return True
-        return False
-
     def _line_inside_not_iron(self, p1, p2):
         for area in self.list_of_areas():
             if area.is_shaft() or area.is_air() or area.is_magnet():
-                if area.is_point_inside(p1):
-                    if area.is_point_inside(p2):
-                        return True
+                if area.is_line_inside(p1, p2):
+                    return True
         return False
 
     def inside_area_list(self, p):

{femagtools-1.8.15 → femagtools-1.8.17}/src/femagtools/dxfsl/machine.py

@@ -1259,6 +1259,11 @@ class Machine(object):
     def has_magnets(self):
         return self.geom.has_magnets
 
+    def magnets_missing(self, EESM):
+        if EESM:
+            return False
+        return not self.has_magnets()
+
     def delete_tiny_elements(self, mindist):
         return self.geom.delete_tiny_elements(mindist)
 
@@ -1320,6 +1325,11 @@ class Machine(object):
                                 self.endangle)
         return self.geom.magnets_in_the_middle(midangle)
 
+    def looking_for_one_possible_magnet(self):
+        midangle = middle_angle(self.startangle,
+                                self.endangle)
+        return self.geom.possible_magnet_in_the_middle(midangle)
+
     def create_mirror_lines_outside_windings(self):
         logger.debug("create_mirror_lines_outside_windings")
 

{femagtools-1.8.15 → femagtools-1.8.17}/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.15 → femagtools-1.8.17}/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.15 → femagtools-1.8.17}/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)
@@ -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.15 → femagtools-1.8.17}/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