femagtools 1.8.4__py3-none-any.whl → 1.8.6__py3-none-any.whl

femagtools/machine/afpm.py

@@ -14,6 +14,8 @@ 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
+from multiprocessing import Pool
 
 logger = logging.getLogger(__name__)
 
@@ -53,7 +55,8 @@ def _integrate(radius, pos, val):
     interp = RegularGridInterpolator((radius, pos), val)
     def func(x, y):
         return interp((x, y))
-    return [quad(func, radius[0], radius[-1], args=(p,))[0]
+    return [quad(func, radius[0], radius[-1],
+                  args=(p,), limit=200)[0]
             for p in pos]
 
 
@@ -61,7 +64,7 @@ def _integrate1d(radius, val):
     interp = make_interp_spline(radius, val, k=1)
     def func(x):
         return interp((x))
-    return quad(func, radius[0], radius[-1])[0]
+    return quad(func, radius[0], radius[-1], limit=100)[0]
 
 def ld_interpol(i1, beta, v):
     '''interpolate Ld at beta angle 0°, -180°'''
@@ -151,7 +154,17 @@ def parident(workdir, engine, temp, machine,
         machine[wdgk].get('num_par_wdgs', 1))
 
     p = machine['poles']
-    num_slices = kwargs.get('num_slices', 3)
+    if np.isscalar(machine['magnet']['afm_rotor']['rel_magn_width']):
+        num_slices = kwargs.get('num_slices', 3)
+        rmagw = num_slices*[machine['magnet']['afm_rotor']['rel_magn_width']]
+    else:
+        rmagw = machine['magnet']['afm_rotor']['rel_magn_width']
+        if len(rmagw) == 1:
+            num_slices = kwargs.get('num_slices', 3)
+            rmagw = num_slices*list(rmagw)
+        else:
+            num_slices = len(rmagw)
+
     lfe = get_arm_lengths(machine['outer_diam'],
                           machine['inner_diam'],
                           num_slices)
@@ -171,6 +184,8 @@ def parident(workdir, engine, temp, machine,
         "decision_vars": [
             {"values": pole_width,
              "name": "pole_width"},
+            {"values": rmagw,
+             "name": "magnet.afm_rotor.rel_magn_width"},
             {"values": lfe,
              "name": "lfe"},
             {"values": linspeed, "name": "speed"}
@@ -215,9 +230,11 @@ def parident(workdir, engine, temp, machine,
         else:
             nlresults = {"x": [], "f": []}
             i = 0
-            for pw, le, sp in zip(pole_width, lfe, linspeed):
+
+            for pw, le, sp, rmw in zip(pole_width, lfe, linspeed, rmagw):
                 nlmachine = {k: machine[k] for k in machine}
                 nlmachine['pole_width'] = pw
+                nlmachine['magnet']['afm_rotor']['rel_magn_width'] = rmw
                 nlmachine['lfe'] = le
                 nlcalc.update({"speed": sp})
                 nlsubdir = f'{workdir}/{i}'
@@ -236,10 +253,11 @@ def parident(workdir, engine, temp, machine,
         current_angles = nlresults['f'][0]['current_angles']
         results = []
         i = 0
-        for l, pw in zip(lfe, pole_width):
+        for l, pw, rmw in zip(lfe, pole_width, rmagw):
             mpart = {k: machine[k] for k in machine if k != 'afm_rotor'}
             mpart['pole_width'] = pw
             mpart['lfe'] = l
+            mpart['magnet']['afm_rotor']['rel_magn_width'] = rmw
             subdir = f"{workdir}/{i}"
 
             simulation = dict(
@@ -295,12 +313,23 @@ def parident(workdir, engine, temp, machine,
             i += 1
 
         postp = []
-        for results in [process(lfe, pole_width, machine, bch)
-                        for bch in zip(*[r['f'] for r in results])]:
-            torque = np.mean(results.pop('torque'))
-            results['torque'] = torque
-            results.update(_psidq_ldq(results, nlresults))
-            postp.append(results)
+        if kwargs.get('use_multiprocessing', True):
+            with Pool() as p:
+                for r in p.starmap(process,
+                                   [(lfe, pole_width, machine, bch)
+                                    for bch in zip(*[r['f']
+                                                     for r in results])]):
+                    torque = np.mean(r.pop('torque'))
+                    r['torque'] = torque
+                    r.update(_psidq_ldq(r, nlresults))
+                    postp.append(r)
+        else:
+            for r in [process(lfe, pole_width, machine, bch)
+                      for bch in zip(*[r['f'] for r in results])]:
+                torque = np.mean(r.pop('torque'))
+                r['torque'] = torque
+                r.update(_psidq_ldq(r, nlresults))
+                postp.append(r)
 
         r1 = postp[0]['r1']
         i1 = [r['i1'] for r in postp][::num_beta_steps]
@@ -395,6 +424,7 @@ def process(lfe, pole_width, machine, bch):
     n = len(rotpos[0])
     currents = [bch[0]['flux'][k][0]['current_k'][:n]
                 for k in bch[0]['flux']]
+
     if len(pole_width) > 1:
         # check homogenity:
         if np.diff([len(d) for d in displ]).any():
@@ -426,6 +456,9 @@ def process(lfe, pole_width, machine, bch):
                        for ux in bch[0]['flux'][k][0]['voltage_dpsi'][:-1]]
                    for k in bch[0]['flux']}
         emf = [voltage[k][:n] for k in voltage]
+        fluxxy = {k: [scale_factor * np.array(flx)
+                      for flx in bch[0]['flux'][k][0]['flux_k']]
+                  for k in bch[0]['flux']}
         flux = [fluxxy[k][:n] for k in fluxxy]
 
     pos = (rotpos[0]/np.pi*180)
@@ -484,7 +517,6 @@ def process(lfe, pole_width, machine, bch):
     except KeyError as exc:
         #logger.warning("missing key %s", exc)
         pass
-
     return {
         'weights': weights.tolist(),
         'pos': pos.tolist(), 'r1': r1,
@@ -598,6 +630,287 @@ 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):
+        beta0 = np.linspace(n*taus, n*taus + taus/2-alpha[0], 5)
+        beta1 = np.linspace(n*taus, n*taus + taus/2-alpha[1], 5)
+        xr = np.concatenate((
+            r[0]*np.cos(beta0), r[1]*np.cos(beta1[::-1])))+xoff
+        yr = np.concatenate((
+            r[0]*np.sin(beta0), r[1]*np.sin(beta1[::-1])))+yoff
+        ax.fill(xr, yr, color=color[0])
+        beta0 = np.linspace(n*taus + taus/2+alpha[0], (n+1)*taus, 5)
+        beta1 = np.linspace(n*taus + taus/2+alpha[1], (n+1)*taus, 5)
+        xr = np.concatenate((
+            r[0]*np.cos(beta0), r[1]*np.cos(beta1[::-1])))
+        yr = np.concatenate((
+            r[0]*np.sin(beta0), r[1]*np.sin(beta1[::-1])))
+        ax.fill(xr, yr, color=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 = max(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 = max(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:
@@ -636,6 +949,14 @@ class AFPM:
         except KeyError:
             raise ValueError("missing key afmtype")
 
+        if np.isscalar(machine['magnet']['afm_rotor']['rel_magn_width']):
+            rmagw = num_slices*[machine['magnet']['afm_rotor']['rel_magn_width']]
+        else:
+            rmagw = machine['magnet']['afm_rotor']['rel_magn_width']
+            if len(rmagw) == 1:
+                rmagw = num_slices*list(rmagw)
+            elif num_slices != len(rmagw):
+                num_slices = len(rmagw)
         lfe = get_arm_lengths(machine['outer_diam'],
                               machine['inner_diam'],
                               num_slices)
@@ -659,11 +980,17 @@ class AFPM:
                  "name": "pole_width"},
                 {"values": lfe,
                  "name": "lfe"},
+                {"values": rmagw,
+                 "name": "magnet.afm_rotor.rel_magn_width"},
                 {"values": linspeed, "name": "speed"}
             ]
         }
+
         machine['pole_width'] = np.pi * machine['inner_diam']/machine['poles']
         machine['lfe'] = machine['outer_diam'] - machine['inner_diam']
+        machine['magnet']['afm_rotor']['rel_magn_width'] = max(
+            machine['magnet']['afm_rotor']['rel_magn_width'])
+
         simulation['skew_displ'] = (simulation.get('skew_angle', 0)/180 * np.pi
                                     * machine['inner_diam'])
         nlresults = {}

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/multiproc.py

@@ -56,7 +56,8 @@ class ProgressLogger(threading.Thread):
                         ["progress_logger",
                          f"{self.numTot}:{numOf}:{percent}:{' '.join(summary)}"])
             else:
-                logger.info('collecting FE losses ...')
+                # TODO: log message might be misleading
+                logger.debug('collecting FE losses ...')
                 return
 
     def stop(self):

femagtools/plot/__init__.py

@@ -1,6 +1,7 @@
 """Creating plots
 
 """
+from .machine import machine
 from .fluxdens import airgap, airgap_fft
 from .bch import torque, torque_fft, force, force_fft, \
     fluxdens_surface, winding_current, winding_flux, \

femagtools/plot/bch.py

@@ -22,6 +22,26 @@ except ImportError:   # ModuleNotFoundError:
 logger = logging.getLogger("femagtools.plot.bch")
 
 
+def find_peaks_and_valleys(t, y):
+    """ return peaks and valleys of y with maximum amplitude
+    """
+    peaks = (np.diff(np.sign(np.diff(y))) < 0).nonzero()[0] + 1
+    if len(peaks > 0):
+        ip = np.argmax(y[peaks])
+        pv = {'yp': y[peaks][ip], 'tp': t[peaks][ip]}
+    else:
+        pv = {'yp': [], 'tp': []}
+    valleys = (np.diff(np.sign(np.diff(y))) > 0).nonzero()[0] + 1
+    if len(valleys > 0):
+        iv = np.argmin(y[valleys])
+        pv.update({'yv': y[valleys][iv], 'tv': t[valleys][iv]})
+    else:
+        pv.update({'yv': [], 'tv': []})
+    pv.update({'peaks': y[peaks], 'valleys': y[valleys],
+               'tpeaks': t[peaks], 'tvalleys': t[valleys]})
+    return pv
+
+
 def _create_3d_axis():
     """creates a subplot with 3d projection if one does not already exist"""
     from matplotlib.projections import get_projection_class
@@ -511,30 +531,62 @@ def transientsc(bch, title=''):
     ax.grid(True)
     istat = np.array([bch.scData[i]
                       for i in ('ia', 'ib', 'ic')])
+    pv = [find_peaks_and_valleys(
+        np.array(bch.scData['time']), i1)
+          for i1 in istat]
+    try:
+        ipvmax = np.argmax(
+            [y['yp'] if np.abs(y['yp']) > np.abs(y['yv']) else y['yv']
+             for y in pv])
+        imax = pv[ipvmax]['yp'] if np.abs(pv[ipvmax]['yp']) > np.abs(pv[ipvmax]['yv']) else pv[ipvmax]['yv']
+    except KeyError:
+        pass
     if np.max(istat) > 4000:
         istat *= 1e-3
+        imax *= 1e-3
         ax.set_title('Currents / kA')
     else:
         ax.set_title('Currents / A')
 
     for i, iph in zip(('ia', 'ib', 'ic'), istat):
         ax.plot(bch.scData['time'], iph, label=i)
+    try:
+        ax.plot([pv[ipvmax]['tp']], [imax], '.')
+        ax.annotate(f'Imax = {imax:.1f}',
+                    xy=(pv[ipvmax]['tp'], imax),
+                    xytext=(pv[ipvmax]['tp']+0.01, imax))
+    except NameError:
+        pass
     ax.set_xlabel('Time / s')
     ax.legend()
 
     row = 2
     plt.subplot(rows, cols, row)
     ax = plt.gca()
-    scale = 1
+    pv = find_peaks_and_valleys(
+        np.array(bch.scData['time']), np.array(bch.scData['torque']))
+    try:
+        tqmax = pv['yp'] if np.abs(pv['yp']) > np.abs(pv['yv']) else pv['yv']
+        tp = pv['tp'] if np.abs(pv['yp']) > np.abs(pv['yv']) else pv['tv']
+    except KeyError:
+        pass
     torque = np.array(bch.scData['torque'])
     if np.max(torque) > 4000:
         torque *= 1e-3
+        tqmax *= 1e-3
         ax.set_title('Torque / kNm')
     else:
         ax.set_title('Torque / Nm')
 
     ax.grid(True)
     ax.plot(bch.scData['time'], torque)
+    try:
+        ax.plot([tp], [tqmax], '.')
+        ax.annotate(f'Tmax = {tqmax:.1f}',
+                    xy=(tp, tqmax),
+                    xytext=(tp+0.01, tqmax))
+    except NameError:
+        pass
     ax.set_xlabel('Time / s')
 
     fig.tight_layout(h_pad=2)
@@ -560,8 +612,10 @@ def transientsc_demag(demag, magnet=0, title='', ax=0):
             label='H Max {:4.2f} kA/m'.format(max(hmax)))
     ax.plot(pos, havg,
             label='H Avg {:4.2f} kA/m'.format(max(havg)))
-    ax.plot([pos[0], pos[-1]], hclim, color='C3', linestyle='dashed',
-            label='Hc {:4.2f} kA/m'.format(hclim[0]))
+    if len(hclim) > 1:
+        ax.plot([pos[0], pos[-1]], hclim, color='C3', linestyle='dashed',
+                label='Hc {:4.2f} kA/m'.format(hclim[0]))
+
     ax.set_xlabel('Rotor Position / °')
     ax.grid(True)
     if magnet:

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)