femagtools 1.8.3__py3-none-any.whl → 1.8.5__py3-none-any.whl

femagtools/machine/afpm.py

@@ -11,9 +11,10 @@ from .. import model
 from .. import utils
 from .. import windings
 from .. import femag
-from scipy.interpolate import RegularGridInterpolator, interp1d, RectBivariateSpline
+from scipy.interpolate import make_interp_spline, RegularGridInterpolator, RectBivariateSpline
 from scipy.integrate import quad
 import copy
+from matplotlib.colors import to_rgb
 
 logger = logging.getLogger(__name__)
 
@@ -58,7 +59,7 @@ def _integrate(radius, pos, val):
 
 
 def _integrate1d(radius, val):
-    interp = interp1d(radius, val)
+    interp = make_interp_spline(radius, val, k=1)
     def func(x):
         return interp((x))
     return quad(func, radius[0], radius[-1])[0]
@@ -598,6 +599,280 @@ def _get_copper_losses(scale_factor, bch):
         return 0  # noload calc has no winding losses
 
 
+def _set_plot_attributes(ax):
+    ax.set_aspect('equal')
+    for loc, spine in ax.spines.items():
+        spine.set_color('none')  # don't draw spine
+    ax.yaxis.set_ticks([])
+    ax.xaxis.set_ticks([])
+
+
+def _get_colors(colors, delta):
+    if delta == 0.0:
+        return colors
+    new_colors = []
+    for col in colors:
+        rgb = to_rgb(col)
+        r, g, b = rgb
+        col = (max(0.0, min(r+delta, 1.0)),
+               max(0.0, min(g+delta, 1.0)),
+               max(0.0, min(b+delta, 1.0)))
+        new_colors.append(col)
+    return new_colors
+
+
+def _draw_vertical_magnets(ax,
+                           poles,
+                           xr, yr,
+                           Rr,
+                           xoff, yoff,
+                           delta=0.0):
+    color = ['green', 'red']
+    color = _get_colors(color, delta)
+    for i in range(poles):
+        ax.fill(xr+xoff, yr+yoff,
+                facecolor=color[i%2], edgecolor=color[i%2])
+        xr, yr = np.dot(Rr, [xr, yr])
+    return
+
+
+def _draw_vertical_slots(ax,
+                         Q,
+                         r,
+                         alpha,
+                         xoff, yoff,
+                         delta=0.0):
+    color = ['skyblue', 'blue']
+    color = _get_colors(color, delta)
+    taus = 2*np.pi/Q
+    for n in range(Q):
+        beta = np.array([[n*taus+alpha[0], (n+1)*taus-alpha[0]],
+                         [(n+1)*taus-alpha[1], n*taus+alpha[1]]])
+        ax.fill(np.hstack((r * np.cos(beta[0, 0]),
+                           (r[::-1] * np.cos(beta[0, 1]))))+xoff,
+                np.hstack((r * np.sin(beta[0, 0]),
+                           (r[::-1] * np.sin(beta[0, 1]))))+yoff,
+                facecolor=color[0], edgecolor=color[0])
+
+
+def vertical_plot(machine, ax):
+    """plots afpm stator and rotor (vertical section)
+    Args:
+      dy1, dy1: float outer, inner diameter
+      rel_magn_width: float rel magnet width 0..1
+      Q: number of stator slots
+      poles: number of poles
+      slot_width: width of stator slot
+    """
+    logger.debug("begin of vertical_plot()")
+
+    model_type = machine['afmtype'][0:4]
+    dy1 = machine['outer_diam']*1e3
+    dy2 = machine['inner_diam']*1e3
+    rel_magn_width = machine['magnet']['afm_rotor']['rel_magn_width']
+    Q = machine['stator']['num_slots']
+    slot_width = machine['stator']['afm_stator']['slot_width']*1e3
+    poles = machine['poles']
+
+    # prepare Magnets
+    theta = np.linspace(np.pi/poles*(1-rel_magn_width),
+                        np.pi/poles*(1+rel_magn_width),
+                        10)
+    xr = np.concatenate((dy1/2 * np.cos(theta), dy2/2 * np.cos(theta[::-1])))
+    yr = np.concatenate((dy1/2 * np.sin(theta), dy2/2 * np.sin(theta[::-1])))
+    rtheta = 2*np.pi/poles
+    Rr = np.array([
+        [np.cos(rtheta), -np.sin(rtheta)],
+        [np.sin(rtheta),  np.cos(rtheta)]
+    ])
+
+    # prepare Slots
+    taus = 2*np.pi/Q
+    r = np.array([dy2/2, dy1/2])
+    alpha = np.arctan2(slot_width/2, r)
+
+    yoff = 0.0
+    xoff = 0.0
+    y_shift = -2
+    x_shift = dy1-dy2
+    ma_delta = 0.0  # color
+    sl_delta = 0.0  # color
+
+    # Draw
+    if model_type in ("S1R2"):  # 2 rotor
+        _draw_vertical_magnets(ax, poles, xr, yr, Rr, xoff, yoff, delta=-0.1)
+        yoff += y_shift
+        xoff += x_shift
+
+    if model_type in ("S2R1"):  # 2 stator
+        sl_delta = -0.1
+
+    _draw_vertical_slots(ax, Q, r, alpha, xoff, yoff, delta=sl_delta)
+    yoff += y_shift
+    xoff += x_shift
+
+    if model_type in ("S1R2"):  # 2 rotor
+        ma_delta = 0.1
+
+    _draw_vertical_magnets(ax, poles, xr, yr, Rr, xoff, yoff, delta=ma_delta)
+    yoff += y_shift
+    xoff += x_shift
+
+    if model_type in ("S2R1"):  # 2 stator
+        sl_delta = 0.0
+        _draw_vertical_slots(ax, Q, r, alpha, xoff, yoff, delta=sl_delta)
+
+    _set_plot_attributes(ax)
+    logger.debug("end of vertical_plot()")
+
+
+IRON_NO = 0
+IRON_UP = 1
+IRON_DOWN = 2
+
+def _draw_horizontal_magnets(ax,
+                             poles,
+                             magn_height,
+                             magn_width,
+                             yoke_height,
+                             Q,
+                             g,
+                             taus,
+                             dy2,
+                             yoff=0.0,
+                             iron=IRON_NO
+                             ):
+    color = ['green', 'red']
+    xy = (0, Q//g*taus, Q//g*taus, 0)
+
+    if iron == IRON_UP:
+        yy = (yoff-yoke_height,
+              yoff-yoke_height,
+              yoff,
+              yoff)
+        yoff -= yoke_height
+        ax.fill(xy, yy, color='skyblue')
+
+    taum = dy2*np.pi/poles
+    ym = np.array([yoff-magn_height,
+                   yoff-magn_height,
+                   yoff,
+                   yoff])
+    yoff -= magn_height
+
+    for n in range(poles//g):
+        xl = taum*n + taum*(1 - magn_width)
+        xr = taum*(n + 1) - taum*(1 - magn_width)
+        xm = (xl, xr, xr, xl)
+        ax.fill(xm, ym, color=color[n%2])
+
+    if iron == IRON_DOWN:
+        yy = (yoff-yoke_height,
+              yoff-yoke_height,
+              yoff,
+              yoff)
+        yoff -= yoke_height
+        ax.fill(xy, yy, color='skyblue')
+    return yoff
+
+
+TOOTH_UP = 0
+TOOTH_DOWN = 1
+TOOTH_ONLY = 2
+
+
+def _draw_horizontal_slots(ax,
+                           slot_height, slot_width, yoke_height,
+                           Q, g, taus,
+                           yoff=0.0,
+                           tooth=TOOTH_DOWN):
+    if not tooth == TOOTH_ONLY:
+        xx = (0, Q//g*taus, Q//g*taus, 0)
+        if tooth == TOOTH_DOWN:
+            yy = (yoff-yoke_height,
+                  yoff-yoke_height,
+                  yoff,
+                  yoff)
+        else:
+            yy = (yoff-slot_height,
+                  yoff-slot_height,
+                  yoff-slot_height-yoke_height,
+                  yoff-slot_height-yoke_height)
+        ax.fill(xx, yy, color='skyblue')
+
+    yt = (yoff-slot_height-yoke_height,
+          yoff-slot_height-yoke_height,
+          yoff, yoff)
+    for n in range(Q//g):
+        xt = np.array((n*taus, n*taus+(taus-slot_width)/2,
+                      n*taus+(taus-slot_width)/2, n*taus))
+        ax.fill(xt, yt, color='skyblue')
+        xt += slot_width + (taus-slot_width)/2
+        ax.fill(xt, yt, color='skyblue')
+    return yoff - slot_height - yoke_height
+
+
+def horizontal_plot(machine, ax):
+    logger.debug("begin of horizontal_plot()")
+
+    model_type = machine['afmtype'][0:4]
+    dy1 = machine['outer_diam']*1e3
+    dy2 = machine['inner_diam']*1e3
+    rel_magn_width = machine['magnet']['afm_rotor']['rel_magn_width']
+    magn_height = machine['magnet']['afm_rotor']['magn_height']*1e3
+    magn_yoke_height = machine['magnet']['afm_rotor']['yoke_height']*1e3
+
+    Q = machine['stator']['num_slots']
+    slot_width = machine['stator']['afm_stator']['slot_width']*1e3
+    poles = machine['poles']
+    m = 3
+    slot_height = machine['stator']['afm_stator']['slot_height']*1e3
+    if model_type in ('S2R1', 'S2R1_all'):
+        slot_height /= 2
+    yoke_height = machine['stator']['afm_stator']['yoke_height']*1e3
+    ag = machine['airgap']*1e3
+
+    g = np.gcd(Q, m*poles)//m
+    taus = dy2*np.pi/Q
+
+    yoff = 0.0
+    if model_type in ('S1R2', 'S1R2_all'):  # 2 rotor
+        yoff = _draw_horizontal_magnets(ax, poles,
+                                        magn_height, rel_magn_width,
+                                        magn_yoke_height,
+                                        Q, g, taus, dy2,
+                                        yoff=yoff,
+                                        iron=IRON_UP)
+        yoff -= ag
+
+    tooth = TOOTH_ONLY if model_type in ('S1R2', 'S1R2_all') else TOOTH_DOWN
+    yoff = _draw_horizontal_slots(ax,
+                                  slot_height, slot_width, yoke_height,
+                                  Q, g, taus,
+                                  yoff=yoff,
+                                  tooth=tooth)
+    yoff -= ag
+
+    iron = IRON_DOWN if model_type in ('S1R1', 'S1R2', 'S1R2_all') else IRON_NO
+    yoff = _draw_horizontal_magnets(ax, poles,
+                                    magn_height, rel_magn_width,
+                                    magn_yoke_height,
+                                    Q, g, taus, dy2,
+                                    yoff=yoff,
+                                    iron=iron)
+    yoff -= ag
+
+    if model_type in ('S2R1', 'S2R1_all'):  # 2 rotor
+        yoff = _draw_horizontal_slots(ax,
+                                      slot_height, slot_width, yoke_height,
+                                      Q, g, taus,
+                                      yoff=yoff,
+                                      tooth=TOOTH_UP)
+
+    _set_plot_attributes(ax)
+    logger.debug("end of horizontal_plot()")
+
+
 class AFPM:
     """Axial Flux PM
     Arguments:

femagtools/machine/effloss.py

@@ -166,9 +166,9 @@ def _generate_mesh(n, T, nb, Tb, npoints):
         nmax = max(n)
         tmin, tmax = 0, max(T)
         tnum = npoints[1]
-    tip = ip.interp1d(n, T)
+    tip = ip.make_interp_spline(n, T, k=1)
     if nb and Tb:
-        tbip = ip.interp1d(nb, Tb)
+        tbip = ip.make_interp_spline(nb, Tb, k=1)
     else:
         def tbip(x): return 0
 

femagtools/machine/im.py

@@ -35,6 +35,9 @@ def log_interp1d(x, y, kind='cubic'):
     logy = np.log10(yy)
     lin_interp = ip.interp1d(logx, logy, kind=kind, fill_value="extrapolate")
     def log_interp(zz): return np.power(10.0, lin_interp(np.log10(zz)))
+    # TODO check replace interp1d
+    #lin_interp = ip.make_interp_spline(logx, logy, bc_type='not-a-knot')
+    #def log_interp(zz): return np.power(10.0, lin_interp(np.log10(zz), nu=1))
     return log_interp
 
 
@@ -792,15 +795,10 @@ def parident(workdir, engine, f1, u1, wdgcon,
     tend = time.time()
     logger.info("Elapsed time %d s Status %s",
                 (tend-tstart), status)
+    if any([x != 'C' for x in status]):
+        raise ValueError("AC simulation failed")
     # collect results
-    results = []
-    errors = []
-    for t in job.tasks:
-        if t.status == 'C':
-            results.append(t.get_results())
-        else:
-            logger.warning("Status %s", t.status)
-            results.append({})
+    results = [t.get_results() for t in job.tasks]
 
     i1_0 = results[0]['i1_0'].tolist()
     psi1_0 = results[0]['psi1_0'].tolist()

femagtools/machine/sm.py

@@ -187,7 +187,7 @@ def parident(workdir, engine, machine,
 
     if simulation['calculationMode'] == 'ld_lq_fast':
         dqpars = dict(m=3, p=b['machine']['p'],
-                      r1=r1,
+                      r1=float(r1),
                       r2=machine['rotor'].get('resistance', 1),
                       rotor_mass=rotor_mass, kfric_b=1,
                       ldq=[dict(
@@ -434,7 +434,7 @@ class SynchronousMachine(object):
     def iqd_tmech(self, torque, n, disp=False, maxiter=500):
         """return currents for shaft torque with minimal losses"""
         if torque > 0:
-            startvals = self.bounds[0][1], 0, self.bounds[-1][1]
+            startvals = self.bounds[0][1]/2, 0, self.bounds[-1][1]
         else:
             startvals = -self.bounds[0][1]/2, 0, self.bounds[-1][1]
 

femagtools/machine/utils.py

@@ -366,7 +366,8 @@ def dqparident(workdir, engine, temp, machine,
     num_beta_steps: number of current steps (default 7 per quadrant)
     speed: rotor speed in 1/s (default 160/p)
     i1_max: maximum current in A rms (default approx 3*i1nom)
-    period_frac: fraction of rotating angle (default 6)
+    period_frac: (int) fraction of rotating angle (default 6)
+    dqtype: (str) type of identification: 'ldq' (default), 'psidq'
     cmd: femag executable
     """
     import pathlib

femagtools/mcv.py

@@ -12,7 +12,7 @@ import pathlib
 import struct
 import math
 import numpy as np
-import scipy.interpolate as ip
+from scipy.interpolate import make_interp_spline
 from six import string_types
 import femagtools.losscoeffs as lc
 
@@ -99,7 +99,7 @@ def norm_pfe(B, pfe):
                 b = list(b)
                 b[-1] = Bv[n]
                 n += 1
-        pfunc = ip.interp1d(b, pfe[i], kind='cubic')
+        pfunc = make_interp_spline(b, pfe[i])
         m.append([float(pfunc(x))
                   for x in Bv[:n]] + [None]*(len(Bv)-n))
     return Bv.tolist(), m
@@ -168,8 +168,7 @@ def recalc_bsin(curve):
         if bi[0] > 0:
             bi.insert(0, 0)
             hi.insert(0, 0)
-        bh = ip.interp1d(bi, hi,
-                         kind='cubic', assume_sorted=True)
+        bh = make_interp_spline(bi, hi)
         for bx in c['bi'][2:]:
             bt = bx*np.sin(2*np.pi/4/ndel*x)
             nue = np.sum(bh(bt)/bt)/ndel
@@ -196,8 +195,7 @@ def recalc_hsin(curve):
         if hi[0] > 0:
             hi.insert(0, 0)
             bi.insert(0, 0)
-        hb = ip.interp1d(hi, bi,
-                         kind='cubic', assume_sorted=True)
+        hb = make_interp_spline(hi, bi)
         for hx in c['hi'][2:]:
             ht = hx*np.sin(2*np.pi/4/ndel*x)
             bt = hb(ht)*np.sin(2*np.pi/4/ndel*x)
@@ -243,11 +241,12 @@ def approx(db2, curve, ctype):
     if ctype in (DEMCRV, MAG_AC_CRV):
         dhdbn = 0
         k = len(bi2)-1
-        if curve['bi'][k] - curve['bi'][k-1] > 0:
-            dhdbn = ((curve['hi'][k] - curve['h'][k-1],KK)
-                     /(curve['bi'][k] - curve['bi'][k-1]))
-        a.append(MUE0*dhdbn)
-        b.append(MUE0*curve['hi'][k] - dhdbn*curve['bi'][k])
+        if k < len(curve['bi']):
+            if curve['bi'][k] - curve['bi'][k-1] > 0:
+                dhdbn = ((curve['hi'][k] - curve['h'][k-1])
+                         /(curve['bi'][k] - curve['bi'][k-1]))
+            a.append(MUE0*dhdbn)
+            b.append(MUE0*curve['hi'][k] - dhdbn*curve['bi'][k])
     else:
         a.append(1.0)
         b.append(MUE0*curve['hi'][-1]-curve['bi'][-1])

femagtools/plot/char.py

@@ -333,10 +333,14 @@ def _plot_contour(speed, torque, z, ax, title='', levels=[],
     clippath = Path(_get_nT_boundary(x, y))
     patch = PathPatch(clippath, facecolor='none')
     ax.add_patch(patch)
-    for c in cont.collections:
-        c.set_clip_path(patch)
-    for c in contf.collections:
-        c.set_clip_path(patch)
+    try:
+        for c in cont.collections:
+            c.set_clip_path(patch)
+        for c in contf.collections:
+            c.set_clip_path(patch)
+    except AttributeError:  # matplotlib >= 3.10
+        cont.set_clip_path(patch)
+        contf.set_clip_path(patch)
 
     if xscale > 1:
         def format_fn(tick_val, tick_pos):
@@ -367,9 +371,16 @@ def efficiency_map(rmap, ax=0, title='', clabel=True,
 
 
 def losses_map(rmap, ax=0, title='Losses Map / kW', clabel=True,
-               cmap='YlOrRd', cbar=False):
+               cmap='YlOrRd', cbar=False, key='losses'):
+    """
+    plot losses map
+    Args:
+    rmap: (dict) result of efficiency_losses_map
+    key: (str) type of losses: 'plfe1', 'plfe2', 'plmag', 'plcu1', 'plcu2', 'plfric', 'losses';
+    """
+
     if ax == 0:
         fig, ax = plt.subplots(figsize=(12, 12))
-    return _plot_contour(rmap['n'], rmap['T'], np.asarray(rmap['losses'])/1e3, ax,
-                        title=title, levels=14, clabel=clabel,
-                        cmap=cmap, cbar=cbar)
+    return _plot_contour(rmap['n'], rmap['T'], np.asarray(rmap[key])/1e3, ax,
+                         title=title, levels=14, clabel=clabel,
+                         cmap=cmap, cbar=cbar)

femagtools/templates/mesh-airgap.mako

@@ -44,10 +44,16 @@ if not airgap_created then
     nc_line(r2, 0.0, x2, y2, 0.0)
 
     if m.tot_num_slot > m.num_sl_gen then
+      if inner_da_end == nil then
+        inner_da_end = inner_da_start
+      end
       x3, y3 = pr2c(inner_da_end, alfa)
       x4, y4 = pr2c(r1, alfa)
       nc_line(x3, y3, x4, y4, 0, 0)
 
+      if outer_da_end == nil then
+        outer_da_end = outer_da_start
+      end
       x3, y3 = pr2c(outer_da_end, alfa)
       x4, y4 = pr2c(r2, alfa)
       nc_line(x3, y3, x4, y4, 0, 0)

femagtools/utils.py

@@ -17,7 +17,7 @@ def fft(pos, y, pmod=0):
     else:
         #negative_periodic = np.abs(y[0] - y[-1])/np.max(y) > 1
         # count zero crossings
-        ypos = np.asarray(y[:-1]) > 0
+        ypos = np.asarray(y)-np.mean(y) > 0
         nypos = ~ypos
         nzc = len(((ypos[:-1] & nypos[1:])
                    | (nypos[:-1] & ypos[1:])).nonzero()[0])

femagtools/windings.py

@@ -179,10 +179,10 @@ class Winding(object):
             nue = n
         else:
             nue = self.kw_order(n)
-        #if q1 == q2:  # integral slot winding
-        #    q = self.Q/2/self.m/self.p
-        #    nuep = nue/self.p
-        #    return np.sin(nuep*np.pi/2/self.m)/q/np.sin(nuep*np.pi/2/self.m/q)
+        if q1 == q2:  # integral slot winding
+            q = self.Q/2/self.m/self.p
+            nuep = nue/self.p
+            return np.sin(nuep*np.pi/2/self.m)/q/np.sin(nuep*np.pi/2/self.m/q)
         k = 2 if self.l == 1 else 1
         a = nue*k*np.pi/self.Q*Yk
         t = self.Q//Qb
@@ -416,6 +416,13 @@ class Winding(object):
              [[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)])
+
         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]
                      for k in m] for m in z]

femagtools/zmq.py

@@ -147,7 +147,6 @@ class SubscriberTask(threading.Thread):
     def send_notify():
         logger.debug(f"Send loop: {SubscriberTask.notify_send_loop}")
         while SubscriberTask.notify_send_loop:
-            logger.debug(f"Send data: {SubscriberTask.notify_send_header}")
             if 'progress_logger' in SubscriberTask.notify_send_header:
                 # collect data from different threads
                 SubscriberTask.notify_send_header.remove('progress_logger')

{femagtools-1.8.3.dist-info → femagtools-1.8.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: femagtools
-Version: 1.8.3
+Version: 1.8.5
 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