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

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/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/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/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/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/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/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/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
 

femagtools/machine/sm.py

@@ -341,7 +341,6 @@ class SynchronousMachine(object):
                 'stteeth_excess':1.5,
                 'rotor_excess': 1.5})
 
-
     def pfric(self, n):
         """friction and windage losses"""
         return 2*np.pi*n*self.tfric
@@ -459,6 +458,13 @@ class SynchronousMachine(object):
             #options={'disp': disp, 'maxiter': maxiter})
             if res['success']:
                 return res.x
+            else: 
+                res = so.minimize(
+                    lambda cur: (self.tmech_iqd(*cur, n) - torque)**2, res.x, method='SLSQP', 
+                    bounds=self.bounds,
+                )
+                if res['success']:
+                    return res.x
 
         logger.warning("%s: torque=%f %f, io=%s",
                        res['message'], torque, self.tmech_iqd(*startvals, n),
@@ -542,10 +548,29 @@ class SynchronousMachine(object):
             log(res.x)
         if res["success"]:
             return *res.x, self.tmech_iqd(*res.x, n)
+        else: 
+            # didn't converge, fullfill voltage and torque demand
+            res = so.minimize(
+                lambda cur: (self.tmech_iqd(*cur, n) - torque)**2, io, method='SLSQP', 
+                bounds=self.bounds,
+                constraints=[
+                {'type': 'eq',
+                 'fun': lambda iqd: np.linalg.norm(
+                     self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}]
+            )
+            if res["success"]:
+                return *res.x, self.tmech_iqd(*res.x, n)
+            else:
+                res = so.minimize(
+                    lambda cur: (self.tmech_iqd(*cur, n) - torque)**2 + 
+                    (np.linalg.norm(self.uqd(w1, *cur)) - u1max*np.sqrt(2))**2, io, method='SLSQP', 
+                    bounds=self.bounds,
+                )
+                return *res.x, self.tmech_iqd(*res.x, n)
 
-        logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-                       res['message'], w1, torque, u1max, io)
-        raise ValueError(res['message'])
+        # logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+        #                res['message'], w1, torque, u1max, io)
+        # raise ValueError(res['message'])
 
     def iqd_torque_umax(self, torque, w1, u1max,
                         disp=False, maxiter=500, log=0, **kwargs):
@@ -622,6 +647,7 @@ class SynchronousMachine(object):
         """
         if kwargs.get('i1max', 0):
             w1type, T = self.w1_imax_umax(kwargs['i1max'], u1max)
+
         try:
             iq, id, iex = self.iqd_torque(T)
         except ValueError:
@@ -689,13 +715,17 @@ class SynchronousMachine(object):
         r['n_type'] = wmType/2/np.pi
         for wm, tq in zip(wmtab, [tload(wx) for wx in wmtab]):
             w1 = wm*self.p
-            if with_tmech:
-                iq, id, iex, tqx = self.iqd_tmech_umax(
-                        tq, w1, u1max)
-            else:
-                iq, id, iex, tqx = self.iqd_torque_umax(
-                        tq, w1, u1max)
-                tqx -= self.tfric
+            if wm > wmType:
+                if with_tmech:
+                    iq, id, iex, tqx = self.iqd_tmech_umax(
+                            tq, w1, u1max)
+                else:
+                    iq, id, iex, tqx = self.iqd_torque_umax(
+                            tq, w1, u1max)
+                    tqx -= self.tfric
+            else: 
+                tqx = Tf
+
             uq, ud = self.uqd(w1, iq, id, iex)
             u1 = np.linalg.norm((uq, ud))/np.sqrt(2)
             f1 = w1/2/np.pi
@@ -708,7 +738,7 @@ class SynchronousMachine(object):
                 beta -= 2*np.pi
             i1 = np.linalg.norm((id, iq), axis=0)/np.sqrt(2.0)
             r['i1'].append(i1)
-            r['beta'].append(beta/180*np.pi)
+            r['beta'].append(beta/np.pi*180)
             gamma = np.arctan2(ud, uq)
             r['cosphi'].append(np.cos(gamma - beta))
             r['plfe1'].append(self.iqd_plfe1(iq, id, iex, f1))
@@ -826,7 +856,10 @@ class SynchronousMachinePsidq(SynchronousMachine):
                 'styoke_eddy', 'stteeth_eddy',
                 'rotor_hyst', 'rotor_eddy')}
 
-
+    def set_max_iex(self, iexc):
+        self.bounds[-1] = (self.bounds[-1][0], iexc) 
+        self.exc_max = iexc
+        
     def psi(self, iq, id, iex):
         """return psid, psiq of currents iq, id"""
         try:
@@ -947,6 +980,10 @@ class SynchronousMachineLdq(SynchronousMachine):
                 'styoke_eddy', 'stteeth_eddy',
                 'rotor_hyst', 'rotor_eddy')}
             pass
+    
+    def set_max_iex(self, iexc):
+        self.bounds[-1] = (self.bounds[-1][0], iexc) 
+        self.exc_max = iexc
 
     def psi(self, iq, id, iex):
         """return psid, psiq of currents iq, id"""

femagtools/plot/char.py

@@ -306,11 +306,18 @@ def _plot_contour(speed, torque, z, ax, title='', levels=[],
     if not levels:
         if max(z) <= 1:
             if max(z) > 0.96:
-                levels = [0.5, 0.75, 0.8, 0.84,
-                          0.89, 0.92, 0.94, 0.96, 0.97]
+                #levels = [0.5, 0.75, 0.8, 0.84,
+                          #0.89, 0.92, 0.94, 0.96, 0.97]
+                levels = np.linspace(min(z),max(z),9)
+                levels = np.round(levels, 2)
+                levels = list(levels)
+
             else:
-                levels = [0.25, 0.5, 0.75, 0.8, 0.84,
-                          0.88, 0.9, 0.92, 0.94, 0.96]
+                #levels = [0.25, 0.5, 0.75, 0.8, 0.84,
+                         #0.88, 0.9, 0.92, 0.94, 0.96]
+                levels = np.linspace(min(z),max(z),9)
+                levels = np.round(levels, 2)
+                levels = list(levels)
 
             if max(z) > levels[-1]:
                 levels.append(np.ceil(max(z)*100)/100)
@@ -376,7 +383,7 @@ def losses_map(rmap, ax=0, title='Losses Map / kW', clabel=True,
     plot losses map
     Args:
     rmap: (dict) result of efficiency_losses_map
-    key: (str) type of losses: 'plfe1', 'plfe2', 'plmag', 'plcu1', 'plcu2', 'plfric', 'losses';
+    key: (str) type of losses: 'losses', 'plfe1', 'plfe2', 'plmag', 'plcu1', 'plcu1_dc', 'plcu1_ac', 'plcu2', 'plfric';
     """
 
     if ax == 0:

femagtools/plot/nc.py

@@ -326,3 +326,12 @@ def temperature_distribution(isa, ax=0, cmap='plasma'):
             ctr = ctr + 1
         temp.append(tmp/ctr)
     _contour(ax, 'Temperature in K', elements, temp, '', cmap)
+
+def punchdist(isa, cmap=DEFAULT_CMAP, ax=0):
+    """plot punching border distances of NC/I7/ISA7 model
+    Args:
+      isa: Isa7/NC object
+    """
+    elam, pdist = isa.punchdist()
+    _contour(ax, 'Punching Border Distances / mm)',
+             elam, pdist*1e3, 'mm', cmap, isa)

femagtools/plot/wdg.py

@@ -7,6 +7,7 @@
 """
 import numpy as np
 import matplotlib.pyplot as plt
+import logging
 
 
 def currdist(wdg, title='', k='all', phi=0, ax=0):
@@ -81,13 +82,13 @@ def mmf_fft(f, title='', mmfmin=1e-2, ax=0):
         pass
 
 
-def zoneplan(wdg, write_title=True, max_slots=0, ax=0):
+def zoneplan(wdg, write_title=True, ax=0, max_slots=0):
     """plot zone plan of winding wdg"""
     from matplotlib.patches import Rectangle
     upper, lower = wdg.zoneplan()
     Qb = len([n for l in upper for n in l])
     if max_slots:
-        Qb = max_slots
+        Qb = min(max_slots, Qb)
     from femagtools.windings import coil_color
     h = 0.5
     w = 1
@@ -171,7 +172,7 @@ def winding_factors(wdg, n=8, ax=0):
         pass
 
 
-def winding(wdg, ax=0):
+def winding(wdg, ax=0, max_slots=0):
     """plot coils of windings wdg"""
     from matplotlib.patches import Rectangle
     from matplotlib.lines import Line2D
@@ -186,12 +187,16 @@ def winding(wdg, ax=0):
     if ax == 0:
         ax = plt.gca()
     z = wdg.zoneplan()
+    z0 = z[0] if len(z[0]) >= len(z[1]) else z[1]
+    Qb = sum([len(l) for l in z0])
+    if max_slots:
+        Qb = min(max_slots, Qb)
     xoff = 0
     if z[-1]:
         xoff = 0.75
     yd = dslot*wdg.yd
     mh = 2*coil_height/yd
-    slots = sorted([abs(n) for m in z[0] for n in m])
+    slots = sorted([abs(n) for m in z[0] for n in m])[:Qb]
     smax = slots[-1]*dslot
     for n in slots:  # draw slots and lamination
         x = n*dslot
@@ -204,6 +209,15 @@ def winding(wdg, ax=0):
                 backgroundcolor="white",
                 bbox=dict(boxstyle='circle,pad=0', fc="white", lw=0))
 
+    # colors in slots
+    csl = [['']*(Qb+1), ['']*(Qb+1)]
+    for i, layer in enumerate(z):
+        for m, mslots in enumerate(layer):
+            for k in mslots:
+                if abs(k) > Qb:
+                    continue
+                csl[i][abs(k)-1] = coil_color[m]
+
     nl = 2 if z[1] else 1
     line_thickness = [0.6, 1.2]
     for i, layer in enumerate(z):
@@ -213,8 +227,9 @@ def winding(wdg, ax=0):
         d = 1
         for m, mslots in enumerate(layer):
             for k in mslots:
+                if abs(k) > Qb:
+                    continue
                 x = abs(k) * dslot + b
-                kcoil = (abs(k)-1)//wdg.yd
                 xpoints = []
                 ypoints = []
                 if nl == 2:
@@ -224,6 +239,12 @@ def winding(wdg, ax=0):
                         d = 1 if i == 1 else 0
                 else:
                     d = 0 if k > 0 else 1
+                    if abs(k) > 1:
+                        if csl[0][abs(k)-2] == coil_color[m]:
+                            d = 1
+                            csl[0][abs(k)-1] = ''
+                        else:
+                            d = 0
 
                 if direction[d] == 'right':
                     # first layer, positive dir or neg. dir and 2-layers:

femagtools/templates/ec-rotorbar.mako

@@ -2,6 +2,10 @@
 --
 -- set rotor bar
 xb, yb = 0, da2/2 - m.slot_height/2 - m.slot_h1
+x1, y1 = pr2c(da2/2-m.slot_h1-m.slot_height/2, zeroangle)
+x10, y10 = pr2c(da2/2-m.slot_h1-m.slot_height/2, zeroangle + 2*math.pi/Q2)
+xb=(x1+x10)/2
+yb=(y1+y10)/2
 muer = 1
 rel = 100
 cur = {1, 0}

femagtools/templates/statorRing.mako

@@ -52,7 +52,7 @@ nc_circle_m(xw2, yw2, x8, y8, 0,0,0)
 nc_circle_m(x4, y4, xw3, yw3, 0,0,0)
 nc_circle_m(xw4, yw4, x7, y7, 0,0,0)
 
-x, y = (x4+x7)/2, (y4+y5)/2
+x, y = (x5+x7)/2, (y7+y5)/2
 create_mesh_se(x, y)
 
 def_new_sreg(x, y, 'StZa', 'skyblue')

femagtools/templates/torq_calc.mako

@@ -67,6 +67,10 @@ m.nu_move_steps   =    ${model.get('num_move_steps', 49)}
 m.num_par_wdgs    =    ${model.get('num_par_wdgs',1)}
 
 m.current         =    ${model.get('current')}*math.sqrt(2.0)/m.num_par_wdgs
+if m.current < 1e-5
+then
+  m.current      =    1e-5*math.sqrt(2.0)
+end
 m.angl_i_up       =    ${model.get('angl_i_up', 0)}
 
 m.pocfilename    = '${model.get('pocfilename', 'sin.poc')}'

femagtools/windings.py

@@ -12,6 +12,12 @@
  Number of coils per phase: c = Q * l/2/m
  Number of parallel circuits (coil groups): g
  Number of turns per phase: w1 = Q * n * l/2/m/g
+
+Refs:
+odd number of phases
+ doi:10.1007/s00502-021-00873-6
+even number of phases
+ doi:10.1049/iet-epa.2020.0553
 """
 import numpy as np
 import femagtools.bch
@@ -131,8 +137,6 @@ def end_wdg_length_hairpins(wire_h, wire_w, wire_th, wire_gap,
 
 
 class Winding(object):
-    # TODO: raise ValueError "Unbalanced winding" if Q % (m * gcd(Q, p)) != 0
-
     def __init__(self, arg):
         """create winding either from bch winding section or winding dict()
 
@@ -199,15 +203,29 @@ class Winding(object):
             coilwidth = self.yd
 
         self.yd = coilwidth
+        if self.m % 2:  # odd number of phases
+            q1, q2, Yk, Qb = q1q2yk(self.Q, self.p, self.m, self.l)
+            j = 2 if layers == 1 else 1
+            k1 = [(q1 + q2)*i for i in range(self.m)]
+            k2 = (q1*(self.m+1) + q2*(self.m-1))//2
+            pos = [[(j*Yk*(k + n)) % Qb
+                    for n in range(q1)] for k in k1]
+            neg = [[j*Yk*(k + n + k2) % Qb
+                    for n in range(q2)] for k in k1]
+        else:  # even number of phases
+            if np.mod(self.Q, 4/self.l*self.m*np.gcd(self.Q, self.p)):
+                raise ValueError(
+                    f"Unbalanced winding: Q={self.Q}, p={self.p}, m={self.m}")
+            t = np.gcd(self.Q, self.p)
+            Qb = self.Q//t
+            seq = np.array([i for j in range(Qb)
+                            for i in range(Qb) if (j*self.p//t - i) % Qb == 0])
+            if self.l == 1:
+                seq = seq[::2]
+            seq = np.array(seq).reshape((-1, 6))
+            pos = seq[::2].T
+            neg = seq[1::2].T
 
-        q1, q2, Yk, Qb = q1q2yk(self.Q, self.p, self.m, self.l)
-        j = 2 if layers == 1 else 1
-        k1 = [(q1 + q2)*i for i in range(self.m)]
-        k2 = (q1*(self.m+1) + q2*(self.m-1))//2
-        pos = [[(j*Yk*(k + n)) % Qb
-                for n in range(q1)] for k in k1]
-        neg = [[j*Yk*(k + n + k2) % Qb
-                for n in range(q2)] for k in k1]
         if self.l > 1:
             slots = [sorted([(k, 1, 1)
                              for k in p] + [(k, -1, 1)
@@ -495,16 +513,16 @@ class Winding(object):
                 if not is_upper(r, s*taus - (x-taus/2))]
                 for key in self.windings]
 
-        z = ([[d*s for s, d in zip(u, ud)] for u, ud in zip(upper, udirs)],
-             [[d*s for s, d in zip(l, ld)] for l, ld in zip(lower, ldirs)])
+        z = ([[int(d*s) for s, d in zip(u, ud)] for u, ud in zip(upper, udirs)],
+             [[int(d*s) for s, d in zip(l, ld)] for l, ld in zip(lower, ldirs)])
         # complete if not  basic winding:
         Qb = self.Q//num_basic_windings(self.Q, self.p, self.l)
 
         if not np.asarray(upper).size or not np.asarray(lower).size:
             layers = 1
         if layers == 1 and z[1]:
-            z = ([[d*s for s, d in zip(l, ld)] for l, ld in zip(lower, ldirs)],
-                 [[d*s for s, d in zip(u, ud)] for u, ud in zip(upper, udirs)])
+            z = ([[int(d*s) for s, d in zip(l, ld)] for l, ld in zip(lower, ldirs)],
+                 [[int(d*s) for s, d in zip(u, ud)] for u, ud in zip(upper, udirs)])
 
         if max([abs(n) for m in z[0] for n in m]) < Qb:
             return [[k + [-n+Qb//2 if n < 0 else -(n+Qb//2) for n in k]

{femagtools-1.8.14.dist-info → femagtools-1.8.16.dist-info}/METADATA

@@ -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.dist-info → femagtools-1.8.16.dist-info}/RECORD

@@ -1,9 +1,9 @@
-femagtools/__init__.py,sha256=gJcP88c10j1_CgFqstAAzR2NxPFwt_-dkoYUz5i2-yk,1601
+femagtools/__init__.py,sha256=yW5kIvW8xbIRiQDkTT8Is4UgEjOhkX7Vqoytu45rvFc,1601
 femagtools/airgap.py,sha256=hELJXe52yUw82JwZ1tGUXUtRhMG2_WSUBVeGkTZSAM8,1900
 femagtools/amazon.py,sha256=O1ICuv21XDAJi1qK1Sigs2TdS6hDZP19OzvmE2t76wU,12069
 femagtools/amela.py,sha256=2q-Xsj6i6nQ3iKheBR1vQ4FulJfF1i-L8w3a3U8GYWo,4362
 femagtools/asm.py,sha256=CiL0KWaF4P7O6-VwmGLdva_icwmPrPiI-TFQ19XYTKk,7660
-femagtools/bch.py,sha256=TC1DKNHuYS9QQNVdBdM1QiMmF6qlT3RnRA4uDMa270c,75623
+femagtools/bch.py,sha256=e6kKyp4iaGb-GPMxwq5LgcyA0GQxteRJDfZsLZVfLyw,75732
 femagtools/bchxml.py,sha256=KrRjAdrUPZXmiWvonu9HhpG_NvImMBpiXWTL4iSr4kE,3142
 femagtools/condor.py,sha256=J8z9iBdvrGu3I1eFNoyKV8AXzRoTEPGLSak6cXUQxAM,10766
 femagtools/conductor.py,sha256=rXO7c7Qh_s7JpgILmLd4IbG64vP6Eh143YF9u25Mdwg,1076
@@ -15,16 +15,16 @@ femagtools/dakotaout.py,sha256=6nn0PXsB40mPKiQLenqAtHy0KXCO7kvqqQ-aD2JhQvw,5573
 femagtools/docker.py,sha256=XDVmLBB0z4sZZpcrx7Wbm84xl4ksj7aqn5-ZOPxdxm4,7460
 femagtools/ecloss.py,sha256=3qwfb_9qpWw99asUDcQgdbP51VGXp4MlLQZDhywWHEk,35051
 femagtools/erg.py,sha256=IXKq76P9qLt_ssNOP78v8Qizk3J2Zg80yaKDSjzwoJE,1224
-femagtools/femag.py,sha256=ejagYsOG9CJDcJQvldq3v3NcZ0OdMC5aipZenc-5MI4,44868
+femagtools/femag.py,sha256=rJ_n1Fvu8RcL-6LTH5o-lvV8pP0kpsqmx6RggsiJMhU,45013
 femagtools/forcedens.py,sha256=7NNv75Vg9vQ_fy8W4kM2rlSO970zaSmeurhPmdAxsOU,8485
-femagtools/fsl.py,sha256=AWyc7mIgUL2tjqw_kmK22y-gZXhTzOccyhjJLwCqKcg,37736
+femagtools/fsl.py,sha256=JSalCD21wyYnlwwXeZjUfTca80RnYezrLvDcewlUH-Q,37976
 femagtools/getset.py,sha256=yJ6Em35DeWK7WNZW0qjjS5s7LUkVh5mbgxF59HHm5FM,3017
 femagtools/gmsh.py,sha256=IKhNiviIBji4cMxAhxaYXNqBRMNAPSKsBGdnGyxkyQw,3903
 femagtools/google.py,sha256=ugRyHY1zBjHR4aNfbA7GeF-ZU_NgleuVTZaWpi_XLT4,17144
 femagtools/grid.py,sha256=s7LfKKLm2H4-cza2kSEANq6vwxq10Su3TJl3kHShHRA,1561
 femagtools/heat_source_network.py,sha256=dz3nTK084SR2fyy1167wlpBlGrzv54OqCCGKPNWqpsU,16836
 femagtools/hxy.py,sha256=PkiZ_-CRhtvtpkmLAP8iMtwvzh7CjKGGcAbOhFb4Nls,6275
-femagtools/isa7.py,sha256=qtmBx53IIbn4rO2pCTFqn0h1f-REbQ0uEWAJ9T85LgI,67033
+femagtools/isa7.py,sha256=8nQtl9Rcceyay9fSlhWu5zeigCyQ7rFQkPLWrYLU1bw,68345
 femagtools/jhb.py,sha256=stJxkmzHpfUIBVcFw7jWbV5KN9_EFqzOCgacyhUqWvM,1779
 femagtools/job.py,sha256=sh4yk8RVEFai7YDBMsVg19p9xEd6_sfyNX5WQSY7HEY,11726
 femagtools/leakinduc.py,sha256=4IGZaV8S1ZG6L3hgZsCXqMsMNRH4F88l9EsvUjSXDSE,999
@@ -49,7 +49,7 @@ femagtools/ts.py,sha256=yoYjpKrr_0b-tHfsX5azJEBXHUs9PN8P-SMhbjjRhCA,48381
 femagtools/utils.py,sha256=yZYgAKHsvK7QyY2-ijE3gSzXlE3vfuhD5dx7myyw434,1703
 femagtools/vbf.py,sha256=9XGfhftmD9carU8ByQ5DwqoR4daq5mJ39eMqruwml0Q,2444
 femagtools/vtu.py,sha256=Sf83dHIfCKY2km-MIUHKKoj-JKN4PDX7kkPLZXyIYY4,10723
-femagtools/windings.py,sha256=p7BkIbi8mMc_CmWqAjOZNKz1-GlQb4kON4rWhvlARf8,27498
+femagtools/windings.py,sha256=eGRoDbi9yruiWHqZysamBLPJefw8IQX3Lq4KpG4oIKo,28216
 femagtools/zmq.py,sha256=62x5VRk0TMNER0-EZ8E28IdLKzsttlbxy1U_3wocNLc,9618
 femagtools/dxfsl/__init__.py,sha256=MywcCdpKPKs4qJBJJgeDsikJFJ2P48dbTuNk303f5pM,76
 femagtools/dxfsl/area.py,sha256=CpTMRBF8_AJmJMkkn-LgRv27U5xJ5Ohhd2ppRvESPNU,69757
@@ -71,12 +71,12 @@ femagtools/dxfsl/shape.py,sha256=uQqbgXIA2_KP2XRdhCfVfGWjcjwzhJ5t9RhiqR9R98c,616
 femagtools/dxfsl/svgparser.py,sha256=RY2TU9MK6gOaNmI6w6RNqcw7H9YGmK-NUwvdylKBcsE,3763
 femagtools/dxfsl/symmetry.py,sha256=dXfZVIqT49nbMirY5YVaRPi8kNB8reaiq-eIbhw1Z54,43936
 femagtools/machine/__init__.py,sha256=xDY9QSUVL2Y17I4fq-nXsb5uMHCIxnCmGVIiL0fZZYE,7447
-femagtools/machine/afpm.py,sha256=ZkYk-acfmwV2ebhU8BUE6dKYkDrCR8UKp1plxEdZ4v8,40223
-femagtools/machine/effloss.py,sha256=vDFKscFTWuW2ro4DRfNdmehQRhMBvqUG7iTm3YaARi8,16431
-femagtools/machine/im.py,sha256=UeN1e0JTwsbaFjGhJFBmhwRDlgckNNf8_A69YmG6ABE,39545
+femagtools/machine/afpm.py,sha256=_Ei1FMuoC1GiI0z90qnyuxNrefkmeRdtDZKm20glzNY,40711
+femagtools/machine/effloss.py,sha256=meQ3bsAORtmn1nMEUfJSiu4YsyfDE5PHc-YNaxnstU4,17093
+femagtools/machine/im.py,sha256=5wYjsEQIiKR62M2M0rA8zmybWQDVjpoazXJPRKyQOvM,40331
 femagtools/machine/pm.py,sha256=hXG71o2TqTxqy-FRy1WoeSOT-KysOGeZlCCnaLfISuE,70026
 femagtools/machine/sizing.py,sha256=QO-k-UALmSPFNf8ajJPDnzKtlbkiAhX1DqWCRLr-H9k,32306
-femagtools/machine/sm.py,sha256=hQC_guN6qCJPrFWyECNyJyVmu13wzPxTioqXnGT4AtA,39191
+femagtools/machine/sm.py,sha256=qZfCIbm02ELH-RsenzqvjZuqRZ-U7OXQq85iOfZphwo,40671
 femagtools/machine/utils.py,sha256=HRM9UHY0UwuBWyK2dAfwlPuvMkXYBVqHlmEsUIdSNJk,21694
 femagtools/moo/__init__.py,sha256=zinmWEOrsEz6DmMX0Dbn4t6_1UR-p4bEGqyR1wUQk_Q,175
 femagtools/moo/algorithm.py,sha256=e-Cgp2rp_hG9DXqWqluzQGNIWvCfthUgLD8O-aVPofA,5763
@@ -87,15 +87,15 @@ femagtools/moo/test/PopulationTest.py,sha256=lG9NeWo0xrslfQRa4tgy1Nj23VJMFIlg_vQ
 femagtools/moo/test/ProblemTest.py,sha256=r5XEfY4LPscDb35TxxPd0lbP3nUmL6_G6vrRo1I3RSg,505
 femagtools/plot/__init__.py,sha256=LFrHy_9L6FxJqhYND2z1534s3ebPXkfXVagFeNA1wWk,978
 femagtools/plot/bch.py,sha256=EhW_YRgMZU4K1Az_XAK1XGG0JAtrDwmwZ6SHdvPi4-c,34085
-femagtools/plot/char.py,sha256=xv4cNOTorK-fy7eUFhmyR-013TFI2A2999xXKgL2AnA,12469
+femagtools/plot/char.py,sha256=8eA1sEt-xKAqOZNlB6tx33DNXVsO3N7ius5KcV9lSv4,12771
 femagtools/plot/fieldlines.py,sha256=_7ykKhnQLeS4fz34pnzovH1gIhcUSKJ3gl1GUgWYix8,1137
 femagtools/plot/fluxdens.py,sha256=NlexRJ3f_8CgKoWrV82ZIsAXPrLhwj98uOe8_fUks7A,1082
 femagtools/plot/forcedens.py,sha256=Vloi9czy7qbGXI-Vm7Cow6IfHTsFhCLI1YWduFOR55c,4075
 femagtools/plot/machine.py,sha256=fVLOZTc19Ru8eXLdtoTeIYsHRWhGLkn_YVZ6qO6KgrE,2654
 femagtools/plot/mcv.py,sha256=ijZg6KPwZC7sDxEzGEUfVWvDoSEfgcaH-hzQMt7E90I,3671
-femagtools/plot/nc.py,sha256=E7_7WNG3MNrV4QPJJqng1nfuXf3ZbjAGeonthqQlMss,11349
+femagtools/plot/nc.py,sha256=OWmO8-WF303z5-zeBGkNJ8N09RJvH7sEYgOuK3LJaR8,11630
 femagtools/plot/phasor.py,sha256=5QG1GkXKVksc8P6Q4thKADf6W1l8rDKeArIHFYvbXlw,4858
-femagtools/plot/wdg.py,sha256=Orw2XGThHpOuJ_raSRnQTzj5tOmwllNWweByoOXbA7I,9820
+femagtools/plot/wdg.py,sha256=uTEtpW_xCXueGnkWx8fTQHruBiayw62AVTXkc9vz9iM,10536
 femagtools/svgfsl/converter.py,sha256=5q4LognshXNTpUWLnU5rtgCfAwZnEuPzqsgyeRYC-VM,3019
 femagtools/templates/FE-losses.mako,sha256=cfDlO11vWovz2muPLg9X2rgeHD9Ihaz8PRiz63MRr88,819
 femagtools/templates/afm_rotor.mako,sha256=4yoEA4fOq9FRcwxOMRw1oX4Bs_jcrtyHOY6kHPYJ5MY,3175
@@ -113,7 +113,7 @@ femagtools/templates/conduct-data.mako,sha256=quT9S1cq2C2GyeoUe-erxV6w20KvRPuJVJ
 femagtools/templates/connect_models.mako,sha256=8j1hzBMeoDJ7-GL5BH-S5p53Bu5jtqqsC2_w6MSwWnI,663
 femagtools/templates/cu_losses.mako,sha256=EeNwINYuwBuhbo9LH3STdQOTxOyyWw_BANgh_BSV9TE,1339
 femagtools/templates/displ_stator_rotor.mako,sha256=dsf9qW0i79aWAbOxaHwWfiq-Tn6WCDx46PQyEvL3SMw,830
-femagtools/templates/ec-rotorbar.mako,sha256=RbA1TVNczEEddTNjvGLPxILExxp4rIgoxXe1YT6a4Is,1672
+femagtools/templates/ec-rotorbar.mako,sha256=fbZ2QTw3YbvWgZJRUEHCnRG_EirdFqCFBiFxlgqQRD4,1833
 femagtools/templates/fe-contr.mako,sha256=Gj4EFpAk_SVW_SIeW5eRRJAsYXTTpl-djuyb47n3Dj8,1898
 femagtools/templates/fieldcalc.mako,sha256=bEtff9HeD6hTpB9t3COt40V1oGeT0a_6ouWTQlKIGX8,749
 femagtools/templates/gen_hairpin_winding.mako,sha256=O3up0yjj3BDqFgpIY28fILKt7NX9NbgXTbd0sb3MM6A,5340
@@ -166,13 +166,13 @@ femagtools/templates/stator2.mako,sha256=7Ae9sfaX7H4ummL6-g8iG42ArUvl6J809TW2tOd
 femagtools/templates/stator3Linear.mako,sha256=pNe3C1wT0W2C0qePo3sEyebW1z_dpTuJzg0r5kf3JQY,760
 femagtools/templates/stator4.mako,sha256=Jq8pfIuOmmpyGOL1z2aQZfbwMS5-Zyn6OGJ51LCBVKs,1179
 femagtools/templates/statorBG.mako,sha256=fh0cVOZVWyLojlGxWJoFz2pvdL6Yxy4xzhY-Joc2xeg,893
-femagtools/templates/statorRing.mako,sha256=sDgDmk71EoE8d4e9cmyqKqRldfC8uKMmpHEjXJGIt_k,2071
+femagtools/templates/statorRing.mako,sha256=_X8t9oAD_6SZ_MlLc450SkN4C6pH4dG5LS09D8bv9SE,2071
 femagtools/templates/statorRotor3.mako,sha256=6ycHlkSnk-TKFdoxiOqjpr6Pk0l634w3_O94vvRP4BI,4357
 femagtools/templates/stator_msh.mako,sha256=Neze1ielMCk7TrARyhOra91fFQVT8Phsgk2Omt_aMG8,1799
 femagtools/templates/therm-dynamic.mako,sha256=pEz7jrUpopK1-RqgulNnrkSaCZDjfLelsVo6cBqmpac,3142
 femagtools/templates/therm_static.mako,sha256=ulevp4AP-kZ1_qdScPMaX9tLqvvP0t9lFflWTXgUxaE,1310
-femagtools/templates/torq_calc.mako,sha256=et6O9ZEkPMOYcaJVpYtH2u3aoU0iyhRCPkfN4ZLdjxA,2353
-femagtools-1.8.14.dist-info/licenses/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
+femagtools/templates/torq_calc.mako,sha256=PH2IXg9ysi0w8N_8YB0IsE3rRj2VE2AYkGortQxFGfQ,2424
+femagtools-1.8.16.dist-info/licenses/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_afpm.py,sha256=ge5CXnVQ7E5gVViTI9hQOC0hHetBci18pY9prbUCAqU,16849
 tests/test_airgap_induction.py,sha256=cmpy1og59oWEyCO4oF_zDuc1DUwCbdeebNL1ujpZza4,1065
@@ -182,26 +182,26 @@ tests/test_bchreader.py,sha256=YPU00nl2MXQiMr1i-W4UOgUvKheeW5tqv_OpTBBOK0g,16835
 tests/test_conductor.py,sha256=T7bmuSdI2Fowwm2Ht-8D0Qnfs1_lx1aoi9RhC2p5nYU,332
 tests/test_convert.py,sha256=oseuhm3Iw-9b4WzBjA_Og2lgXPqKYicLUnfadq5Yick,6497
 tests/test_dxfsl.py,sha256=DBAjtwNAwcB7VYZBjul7xf4ovu14n3Z0fxyreVzAW4A,383
-tests/test_effloss.py,sha256=-kJJNgS5c6saHXjNuhAe5GdWfr9mEYpPo8fE8OtjsNA,1142
+tests/test_effloss.py,sha256=pBGuzUeyDZ5jUp92jvVSVPOa4r_5bBYZ1GZH5HRdV3o,1158
 tests/test_erg.py,sha256=kRVzpXa6JDdbxTss18HUWKny9Dx8IMx9uGTrbQCnHwg,523
 tests/test_femag.py,sha256=l7-av3eitLm7bwTuunEmVeTspi82ifPrlz7f1boGdVI,1934
 tests/test_forcedens.py,sha256=Yzl3SAmJNkZN9dA3aLxRvwY8fKsw077Fl0iJm6zJ5Sk,536
-tests/test_fsl.py,sha256=oe5dHxR0G3sfGvsRtO6fEIn0R3oQFugsSkGzhyFPQR4,16624
+tests/test_fsl.py,sha256=mSk7de5IenY_iWJDgxdKRqZVza4P3gw8s1Hayl7kIYw,16624
 tests/test_heat_source_network.py,sha256=TC-Gl4iy9jnMGfsY_24XjwlP-SDxP345JKVT8xRwsFo,690
 tests/test_hxy.py,sha256=pVb6ZfDhBy5-DXa3gh7RQmLFG8p5cSYB8gdGLC8kjAk,640
-tests/test_im.py,sha256=55wfCoA8_PuogI_RsC3AjUQCpR84T-HddtHuU1NxfPc,662
+tests/test_im.py,sha256=RU2SJKvXsavQSth2sHjeOs-eXNegz9GQXTUCcow8H3s,1888
 tests/test_isa7.py,sha256=GJhRj2nncrUpNTIlM4jvG4kKZS7cK19hhQg9KbM3b5Q,3001
 tests/test_jhb.py,sha256=aDzwr2ZaXlizrPnlLlcI_IT3OpSxuKu-FzBBkIALEDg,824
 tests/test_job.py,sha256=1tCTPqd2LUeeVNuzC07lsPz4ffr0WAVX_BykyXQ2mZY,981
 tests/test_losscoeffs.py,sha256=3EKmDFRuvn88z_8r0HxKFdB0lNXNnhEgaFshL8BkDjE,2012
-tests/test_machine.py,sha256=Woha6nfKaYQCxxoG57sUztpnpU6K9imXwn9B_KMhanw,12906
+tests/test_machine.py,sha256=BBaeypcFCpGZfJM52_rUIrA3uu17n4_IT1Y05W_caSA,12960
 tests/test_magncurv.py,sha256=wPf1dNACZ1BkqKHSqJxiNi6Dq8JP3QCRBY4ql_0YCyU,2608
 tests/test_magnet.py,sha256=BUHG_8SEi4d8j6yV9BSzcpYc2-UVMRFv50P_jgTTXoQ,276
 tests/test_mcv.py,sha256=Vv51WU3WU0AkgcSpyujMdJ2KvSdLNsks5HGtY0pWMOY,4749
 tests/test_mcvreader.py,sha256=3cgq22b_iaWLrs4WWOUNHqJREnv0YoFivNpAb4teEJs,2118
 tests/test_me.py,sha256=En00OrOhZclBO4u74q5Os0FgVP4TGFLzz99LF0QHXHA,196
 tests/test_model.py,sha256=kYjjFgZPIex3foX3skiOdD5MCcmA2JP7oDDuE9txv_U,2698
-tests/test_nc.py,sha256=Qhd8SppnWULcEiGphhhn4K_8PfhV7Wh17NAC63R_-N0,4630
+tests/test_nc.py,sha256=lx46Yeco1nuwTtBe4XmdR92tkD9FLmL1VcJgMg-rrLU,5198
 tests/test_parident.py,sha256=zwj-f-Q_s5dBr_fEvzd5iZqNVIcLwkoi_FF2_FNTiaw,1393
 tests/test_parstudy.py,sha256=wk7WfYQrx5dtv6MnmWCfNAEInvRKsbVXYEUIIR9zLbQ,3200
 tests/test_pocfile.py,sha256=eiMLBRQxDnHIGiqku6EXcQ3fb7wGIxhXmb20iyLlPRU,5816
@@ -211,7 +211,7 @@ tests/test_tksreader.py,sha256=8QtPAzxPJbkpxd1Nw2I7ggaTaKaL4WY55JJBHkZAzus,766
 tests/test_ts.py,sha256=tR2x5cKU9gw2fUprzaPgPbCvmDOHDO36JUPCCoTlY7Y,1833
 tests/test_vbfreader.py,sha256=-6oAhLJDb7K3Ui5O1mtHvbskawEfgyIH-Of5n-8u-fc,832
 tests/test_vtu.py,sha256=pGpHuAcaCk5zDYTBBp_akOEenZOpq-IzGl_kaMtodyA,1469
-tests/test_windings.py,sha256=rZjAudsSCHedbo5BWt1ZVaU49ktxjOim1r7BzJmSdUo,5841
+tests/test_windings.py,sha256=WKFabGC6-TpCnxXL9U91J84INK_ntkMMU1FZRuE7m6k,6142
 tests/engines/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/engines/test_amazon.py,sha256=4uy36NIo0epi3CgjUm8vl4snLpr4NRvUoWi6Zew_zcE,2014
 tests/engines/test_config.py,sha256=_I1Z5RuubgnOGQeZHjAsCsovt0WEMH0o4ILz032l_Bc,663
@@ -222,8 +222,8 @@ tests/moo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/moo/test_algorithm.py,sha256=Em8sFm2vzPmuIzRrBBnUQLU_TYuJHSf-kEeozw0XeX4,2563
 tests/moo/test_population.py,sha256=FvX9LRCxQx0_E2GxHQ5vKwOYFBQiNbT6Lmv5GmNWjTQ,5471
 tests/moo/test_problem.py,sha256=ALeP4u7g-dFhfwWL8vxivdrrYzVKPjHMCAXzzgyNZbs,467
-femagtools-1.8.14.dist-info/METADATA,sha256=BrabUwTwkjyUIeeY3Ln1RIyfy1FQefxu8EgDckCsobA,6213
-femagtools-1.8.14.dist-info/WHEEL,sha256=DnLRTWE75wApRYVsjgc6wsVswC54sMSJhAEd4xhDpBk,91
-femagtools-1.8.14.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
-femagtools-1.8.14.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.8.14.dist-info/RECORD,,
+femagtools-1.8.16.dist-info/METADATA,sha256=H9y1DOCVUWBJhZgyHDJa1Vqt9r7xHZg9rZUiWXUxEoQ,6213
+femagtools-1.8.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+femagtools-1.8.16.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
+femagtools-1.8.16.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
+femagtools-1.8.16.dist-info/RECORD,,

{femagtools-1.8.14.dist-info → femagtools-1.8.16.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.4.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

tests/test_effloss.py

@@ -14,7 +14,7 @@ def impars():
             'im': [2.043764851047857, 4.087529702095714, 6.1312945531435705,
                    8.175059404191428, 10.218824255239285],
             'psi': [0.27117452078113785, 0.5286659550273167, 0.7135568973434478,
-                    0.8133415467307101, 0.8671946085010127]}
+                    0.8133415467307101, 0.8671946085010127], 'tfric': 0.099}
 
 
 def test_imeffloss(impars):

tests/test_fsl.py

@@ -327,7 +327,7 @@ class FslBuilderTest(unittest.TestCase):
 
         feapars['calculationMode'] = "torq_calc"
         fsl = self.builder.create_analysis(feapars)
-        self.assertEqual(len(fsl), 28)
+        self.assertEqual(len(fsl), 32)
 
     def test_run_existing_model(self):
         model = femagtools.MachineModel('data/magnsec')

tests/test_im.py

@@ -3,6 +3,7 @@ import pathlib
 import pytest
 import numpy as np
 
+from femagtools.machine.im import InductionMachine
 
 @pytest.fixture
 def im():
@@ -21,3 +22,28 @@ def test_im(im):
     s = 0.01
     torque = im.torqueu(2*np.pi*f1, u1, 2*np.pi*(1-s)*f1/im.p)
     assert pytest.approx(torque, rel=0.01) == 17.77
+
+def test_characteristics():
+    m = {'r1': 0.675074272807, 'ls': 0.0, 'le': 0.0, 'wdgcon': 1.0, 'bar_temp': 80.0, 
+         'im': [0.815370706376, 3.15956148721, 5.50375226804, 7.84794304887, 10.1921338297], 
+         'psi': [0.110531890489, 0.42241005873, 0.64470403922, 0.742820604784, 0.791593101916],  
+         'lsigma1': 0.00282975049013, 'lsigma2': 0.00170976658221, 'r2': 0.526553117684, 
+         'u1ref': 230.940107676, 'f1ref': 49.9998282765, 'rotor_mass': 10.0742734696, 'kfric_b': 1.0,
+         'zeta2': 0.983497740554, 'pl2v': 0.801009432234, 'psiref': 0.717940875943, 'wref': 314.158186388, 
+         'fec': 61.5, 'fee': 0.0, 'fexp': 7.0,  'kth1': 0.0039, 'kth2': 0.0039, 'p': 4, 'm': 3, 'u_1': 165.0}
+    
+    op = {'n': [0.0, 16.0, 41.0], 
+          'T': [50.0, 47.5, 42.5]}
+
+    tmech = True
+    im = InductionMachine(m)
+    u1 = m['u_1']
+    m.pop('u_1')
+
+    r = im.characteristics(op['T'], op['n'], u1,with_tmech=tmech)
+
+    expected = {'losses': [237.01, 237.12, 236.46],
+                  'eta': [0, 0.76, 0.88]}
+    
+    assert pytest.approx(expected['losses'], rel=1e-1) == r['losses']
+    assert pytest.approx(expected['eta'], rel=1e-1) == r['eta']

tests/test_machine.py

@@ -169,7 +169,7 @@ def test_char_ldd_fieldweakening():
     assert r['beta'][0] == pytest.approx(-30.0, rel=1e-1)
     assert r['cosphi'][0] == pytest.approx(0.729, rel=1e-1)
 
-
+@pytest.mark.skip(reason="fixit: returns currently 0")
 def test_i1beta_char():
     m = dict(
         p=4,

tests/test_nc.py

@@ -1,3 +1,4 @@
+import numpy as np
 import pytest
 from femagtools import nc
 from femagtools import isa7
@@ -165,3 +166,19 @@ def test_windings(disp_stat):
 def test_magnet_super_elements(disp_stat):
     sekeys = [se.key for se in disp_stat.magnet_super_elements()]
     assert sekeys == [98, 101, 74, 77, 80, 83, 86, 89, 92, 95]
+
+
+def test_punchdist(pm):
+    expected_shape = ((1008, 2), (520, 2))
+    for i, name in enumerate(pm.get_iron_subregions()):
+        sr = pm.get_subregion(name)
+        bnxy, bkeys = sr.nonper_border_nodes()
+        assert expected_shape[i] == np.shape(bnxy)
+        assert expected_shape[i][0] == 2*len(bkeys)
+
+    bnxy = pm.lamination_border()
+    assert (764, 2) == np.shape(bnxy)
+    elam, pdist = pm.punchdist()
+    assert 6714 == len(elam)
+    assert (6714, ) == np.shape(pdist)
+    assert pytest.approx(0.0041973, abs(1e-3)) == np.max(pdist)

tests/test_windings.py

@@ -163,3 +163,14 @@ def test_zoneplan():
     w = femagtools.windings.Winding(
         {'Q': 60, 'p': 32, 'm': 3, 'l': 1})
     assert [1, -2, 3, -4, 5, -6, -17, 18, -19, 20] == w.zoneplan()[0][0]
+
+def test_zoneplan_6phase():
+    w = femagtools.windings.Winding(
+        {'Q': 24, 'p': 11, 'm': 6, 'l': 1})
+    assert [
+        [1, -2, -13, 14],
+        [-11, 12, 23, -24],
+        [-9, 10, 21, -22],
+        [-7, 8, 19, -20],
+        [-5, 6, 17, -18],
+        [-3, 4, 15, -16]] == w.zoneplan()[0]