femagtools 1.8.4__tar.gz → 1.8.5__tar.gz

{femagtools-1.8.4/src/femagtools.egg-info → femagtools-1.8.5}/PKG-INFO

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

{femagtools-1.8.4 → femagtools-1.8.5}/src/femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.4'
+__version__ = '1.8.5'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2024 Gamma Technology'

{femagtools-1.8.4 → femagtools-1.8.5}/src/femagtools/dxfsl/converter.py

@@ -21,7 +21,6 @@ import sys
 import multiprocessing
 
 logger = logging.getLogger(__name__)
-journal = None
 
 
 def plot_geom(doit, plt, geom, title="Plot", areas=True):
@@ -279,7 +278,6 @@ def symmetry_search(machine,
 
 
 def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
-    global journal
     logger.debug("Begin of build_machine_rotor")
 
     if machine.has_windings():
@@ -350,14 +348,12 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
               title="Final Rotor")
 
     t = timer.stop("-- rotor created in %0.4f seconds --")
-    journal.put('time_rotor_created', t)
 
     logger.debug("End of build_machine_rotor")
     return machine_temp
 
 
 def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False):
-    global journal
     logger.debug("Begin of build_machine_stator")
     timer = Timer(start_it=True)
 
@@ -424,7 +420,6 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
               title="Final Stator")
 
     t = timer.stop("-- stator created in %0.4f seconds --")
-    journal.put('time_stator_created', t)
 
     logger.debug("End of build_machine_stator")
     return machine_temp

{femagtools-1.8.4 → femagtools-1.8.5}/src/femagtools/machine/afpm.py

@@ -14,6 +14,7 @@ from .. import femag
 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__)
 
@@ -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-1.8.4 → femagtools-1.8.5}/src/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-1.8.4 → femagtools-1.8.5}/src/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-1.8.4 → femagtools-1.8.5}/src/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])-np.mean(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-1.8.4 → femagtools-1.8.5}/src/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.4 → femagtools-1.8.5/src/femagtools.egg-info}/PKG-INFO

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