femagtools 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

femagtools/plot.py

@@ -229,7 +229,7 @@ def airgap_fft(airgap, bmin=1e-2, ax=0):
         pass
 
 
-def torque(pos, torque, ax=0):
+def torque(pos, torque, title='', ax=0):
     """creates plot from torque vs position"""
     k = 20
     alpha = np.linspace(pos[0], pos[-1],
@@ -242,7 +242,10 @@ def torque(pos, torque, ax=0):
         unit = 'kNm'
     if ax == 0:
         ax = plt.gca()
-    ax.set_title('Torque / {}'.format(unit))
+    if title:
+        ax.set_title(title)
+    else:
+        ax.set_title('Torque / {}'.format(unit))
     ax.grid(True)
     ax.plot(pos, [scale*t for t in torque], 'go')
     ax.plot(alpha, scale*f(alpha))
@@ -896,7 +899,34 @@ def transientsc(bch, title=''):
     fig.tight_layout(h_pad=2)
     if title:
         fig.subplots_adjust(top=0.92)
+    return fig
 
+def transientsc_demag(demag, magnet=0, title='', ax=0):
+    """creates a demag plot of a transient short circuit
+    Args:
+      demag: list of dicts with 'displ', 'H_av', 'H_max', 'lim_hc'
+      magnet dict with 'Tmag'
+    """
+    if ax == 0:
+        ax = plt.gca()
+    pos = [d['displ'] for d in demag if 'displ' in d]
+    hmax = [-d['H_max'] for d in demag if 'H_max' in d]
+    havg = [-d['H_av'] for d in demag if 'H_av' in d]
+    hclim = [-d['lim_hc'] for d in demag if 'lim_hc' in d]*2
+
+    ax.set_title('Transient Short Circuit Demagnetization [kA/m]')
+    ax.plot(pos, hmax,
+            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]))
+    ax.set_xlabel('Rotor Position / °')
+    ax.grid(True)
+    if magnet:
+        ax.legend(title=f"Magnet Temperature {magnet['Tmag']}°C")
+    else:
+        ax.legend()
 
 def i1beta_torque(i1, beta, torque, title='', ax=0):
     """creates a surface plot of torque vs i1, beta"""
@@ -1222,7 +1252,7 @@ def _contour(ax, title, elements, values, label='', isa=None):
     if ax == 0:
         ax = plt.gca()
     ax.set_aspect('equal')
-    ax.set_title(title, fontsize=18)
+    ax.set_title(title)
     if isa:
         for se in isa.superelements:
             ax.add_patch(Polygon([n.xy
@@ -1236,13 +1266,13 @@ def _contour(ax, title, elements, values, label='', isa=None):
     p = PatchCollection(patches, alpha=1.0, match_original=False)
     p.set_array(np.asarray(values)[valid_values])
     ax.add_collection(p)
-    cb = plt.colorbar(p)
+    cb = plt.colorbar(p, shrink=0.9)
     for patch in np.array([Polygon([v.xy for v in e.vertices],
                                    fc='white', alpha=1.0)
                            for e in elements])[np.isnan(values)]:
         ax.add_patch(patch)
     if label:
-        cb.set_label(label=label, fontsize=18)
+        cb.set_label(label=label)
     ax.autoscale(enable=True)
     ax.axis('off')
 
@@ -1254,29 +1284,35 @@ def demag(isa, ax=0):
     """
     emag = [e for e in isa.elements if e.is_magnet()]
     demag = np.array([e.demagnetization(isa.MAGN_TEMPERATURE) for e in emag])
-    _contour(ax, f'Demagnetization at {isa.MAGN_TEMPERATURE} °C',
+    _contour(ax, f'Demagnetization at {isa.MAGN_TEMPERATURE} °C (max -{np.max(demag):.1f} kA/m)',
              emag, demag, '-H / kA/m', isa)
     logger.info("Max demagnetization %f", np.max(demag))
 
 
-def demag_pos(isa, pos, icur=-1, ibeta=-1, ax=0):
+def demag_pos(isa, pos=-1, icur=-1, ibeta=-1, ax=0):
     """plot demag of NC/I7/ISA7 model at rotor position
     Args:
       isa: Isa7/NC object
-      pos: rotor position in degree
+      pos: rotor position in degree (maximum h if -1)
       icur: cur amplitude index or last index if -1
       ibeta: beta angle index or last index if -1
     """
     emag = [e for e in isa.elements if e.is_magnet()]
     demag = np.array([isa.demagnetization(e, icur, ibeta)[1]
                       for e in emag])
-    for i, x in enumerate(isa.pos_el_fe_induction):
-        if x >= pos/180*np.pi:
-            break
+    if pos>=0:
+        for i, x in enumerate(isa.pos_el_fe_induction):
+            if x >= pos/180*np.pi:
+                break
+    else:
+        demagmax = np.max(demag, axis=0)
+        i = np.argmax(demagmax)
+        x = isa.pos_el_fe_induction[i]
 
     hpol = demag[:, i]
     hpol[hpol == 0] = np.nan
-    _contour(ax, f'Demagnetization at Pos. {round(x/np.pi*180)}° ({isa.MAGN_TEMPERATURE} °C)',
+    _contour(ax, f'Demagnetization at pos. {round(x/np.pi*180):.1f}°,'
+    f'{isa.MAGN_TEMPERATURE} °C (max -{np.max(hpol):.1f} kA/m)',
              emag, hpol, '-H / kA/m', isa)
     logger.info("Max demagnetization %f kA/m", np.nanmax(hpol))
 
@@ -1297,7 +1333,7 @@ def flux_density(isa, subreg=[], ax=0):
         elements = [e for e in isa.elements]
 
     fluxd = np.array([np.linalg.norm(e.flux_density()) for e in elements])
-    _contour(ax, f'Flux Density T', elements, fluxd)
+    _contour(ax, f'Flux Density T (max {np.max(fluxd):.1f} T)', elements, fluxd)
     logger.info("Max flux dens %f", np.max(fluxd))
 
 
@@ -1311,8 +1347,9 @@ def loss_density(isa, subreg=[], ax=0):
             sr = subreg
         else:
             sr = [subreg]
-        elements = [e for s in sr for sre in isa.get_subregion(s).elements()
-                    for e in sre]
+        elements = [e
+                    for s in sr
+                    for e in isa.get_subregion(s).elements()]
     else:
         elements = [e for e in isa.elements]
 
@@ -1652,15 +1689,26 @@ def characteristics(char, title=''):
         fig.suptitle(title)
 
     n = np.array(char['n'])*60
-    pmech = np.array(char['pmech'])*1e-3
+    punit = 'kW'
+    k = 1e-3
+    if max(char['pmech']) > 1e6:
+        punit = 'MW'
+        k = 1e-6
+    pmech = np.array(char['pmech'])*k
+    tunit = 'Nm'
+    if max(char['T']) > 1e3:
+        tunit = 'kNm'
+        tq = np.array(char['T'])*1e-3
+    else:
+        tq = np.array(char['T'])
 
-    axs[0, 0].plot(n, np.array(char['T']), 'C0-', label='Torque')
-    axs[0, 0].set_ylabel("Torque / Nm")
+    axs[0, 0].plot(n, tq, 'C0-', label='Torque')
+    axs[0, 0].set_ylabel(f"Torque / {tunit}")
     axs[0, 0].grid()
     axs[0, 0].legend(loc='center left')
     ax1 = axs[0, 0].twinx()
     ax1.plot(n, pmech, 'C1-', label='P mech')
-    ax1.set_ylabel("Power / kW")
+    ax1.set_ylabel(f"Power / {punit}")
     ax1.legend(loc='lower center')
 
     axs[0, 1].plot(n[1:], np.array(char['u1'][1:]), 'C0-', label='Voltage')
@@ -1697,6 +1745,12 @@ def characteristics(char, title=''):
     pl = np.array(char['losses'])*1e-3
     axs[1, 1].plot(n, plcu, 'C0-', label='Cu Losses')
     axs[1, 1].plot(n, plfe, 'C1-', label='Fe Losses')
+    try:
+        if char['plfw'] and char['plfw'][-1] > 0:
+            plfw = np.array(char['plfw'])*1e-3
+            axs[1, 1].plot(n, plfw, 'C2-', label='Friction + Windage')
+    except KeyError:
+            pass
     axs[1, 1].set_ylabel("Losses / kW")
     axs[1, 1].legend(loc='center left')
     axs[1, 1].grid()
@@ -1724,12 +1778,62 @@ def get_nT_boundary(n, T):
     bnd[1].append((nx, tx))
     return np.array(bnd[0] + bnd[1][::-1])
 
+def normalize10(v, **kwargs):
+    """
+    Normalizes the input-array using the nearest (ceiling) power of 10.
+
+    Arguments:
+        v: array to normalize
 
-def plot_contour(speed, torque, z, ax, title='', levels=[], clabel=True):
+    Returns:
+        normalized array
+        normalisation factor (power of 10)
+    """
+    n_type = kwargs.get('n_type', 'abs') # 'norm')
+    r_type = kwargs.get('r_type', 'round') # 'floor')
+    if n_type == 'norm':
+        norm = np.log10(np.linalg.norm(v))
+    elif n_type == 'abs':
+        norm = np.log10(np.max(np.abs(v)))
+    else:
+        raise AttributeError('Unknown norm-type. Allowed values are: "norm", "abs".')
+
+    if r_type == 'floor':
+        norm = 10 ** np.floor(norm)
+    elif r_type == 'ceil':
+        norm = 10 ** np.ceil(norm)
+    elif r_type == 'round':
+        norm = 10 ** np.round(norm)
+    else:
+        raise AttributeError('Unknown rounding type. Allowed values are: "floor", "ceil", "round".')
+    # norm = 10**(np.ceil(np.log10(np.max(np.abs(v)))))
+    # norm = 10 ** (np.ceil(np.log10(np.linalg.norm(v))))
+    # norm = 10 ** (np.floor(np.log10(np.max(np.abs(v)))))
+    # norm = 10 ** (np.floor(np.log10(np.linalg.norm(v))))
+    return v / norm, norm
+
+
+def plot_contour(speed, torque, z, ax, title='', levels=[],
+                 clabel=True, cmap='YlOrRd', cbar=False, **kwargs):
+    """ contour plot of speed, torque, z values
+    Arguments:
+    levels: (list of floats)
+    clabel: contour labels if True
+    cmap: colour map
+    cbar: (bool) create color bar if True (default False)
+
+    Note: the x and y axes are scaled
+
+    returns tricontourf, xscale, yscale
+    """
     from matplotlib.path import Path
     from matplotlib.patches import PathPatch
-    x = [60*n for n in speed]
-    y = torque
+    x = 60*np.asarray(speed)
+    y = np.asarray(torque)
+
+    x, xscale = normalize10(x, **kwargs)
+    y, yscale = normalize10(y, **kwargs)
+
     if not levels:
         if max(z) <= 1:
             if max(z) > 0.96:
@@ -1743,38 +1847,58 @@ def plot_contour(speed, torque, z, ax, title='', levels=[], clabel=True):
                 levels.append(np.ceil(max(z)*100)/100)
         else:
             levels = 14
-    cont = ax.tricontour(x, y, z,
-                         linewidths=0.4, levels=levels, colors='k')
-    if clabel:
-        ax.clabel(cont, inline=True, colors='k', fontsize=8)
-    contf = ax.tricontourf(x, y, z,
-                           levels=levels, cmap='YlOrRd')
     #
     ax.spines['top'].set_color('none')
     ax.spines['right'].set_color('none')
 
+    cont = ax.tricontour(x, y, z,
+                         linewidths=0.4, levels=levels,
+                         colors='k')
+    contf = ax.tricontourf(x, y, z,
+                           levels=levels, cmap=cmap)
+
     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)
+    #ax.plot(x, y, "k.", ms=3)
+    if clabel:
+        ax.clabel(cont, inline=True, colors='k', fontsize=8, inline_spacing=0)
+
     for c in contf.collections:
         c.set_clip_path(patch)
-    #ax.plot(x, y, "k.", ms=3)
+
+    if xscale > 1:
+        def format_fn(tick_val, tick_pos):
+            return round(xscale*tick_val)
+        ax.xaxis.set_major_formatter(format_fn)
+    if yscale > 1:
+        def format_fn(tick_val, tick_pos):
+            return round(yscale*tick_val)
+        ax.yaxis.set_major_formatter(format_fn)
+
     ax.set_ylabel('Torque / Nm')
     ax.set_xlabel('Speed / rpm')
     ax.set_title(title)
-    return contf
+    if cbar:
+        cfig = ax.get_figure()
+        cfig.colorbar(contf, ax=ax,
+                      orientation='vertical')
+    return contf, xscale, yscale
+
 
-def efficiency_map(rmap, ax=0, title='Efficiency Map', clabel=True):
+def efficiency_map(rmap, ax=0, title='Efficiency Map', clabel=True,
+                   cmap='YlOrRd', levels=None, cbar=False):
     if ax == 0:
         fig, ax = plt.subplots(figsize=(12, 12))
-    contf = plot_contour(rmap['n'], rmap['T'], rmap['eta'], ax,
-                         title=title, clabel=clabel)
-    return contf
+    return plot_contour(rmap['n'], rmap['T'], rmap['eta'], ax,
+                        title=title, clabel=clabel, cmap=cmap,
+                        levels=levels, cbar=cbar)
 
 
-def losses_map(rmap, ax=0, title='Losses Map / kW', clabel=True):
+def losses_map(rmap, ax=0, title='Losses Map / kW', clabel=True,
+               cmap='YlOrRd', cbar=False):
     if ax == 0:
         fig, ax = plt.subplots(figsize=(12, 12))
     return plot_contour(rmap['n'], rmap['T'], np.asarray(rmap['losses'])/1e3, ax,

femagtools/templates/afm_rotor.mako

@@ -0,0 +1,102 @@
+-- Create model of the rotor of the axial flow machine
+
+m.yoke_height  = ${model['yoke_height']*1e3}  -- Yoke height [mm]
+m.magn_height     = ${model['magn_height']*1e3}  -- Magnet height [mm]
+m.magn_width      = ${model['rel_magn_width']*1e2}  -- Magnet width: >0:[%]; <0: [mm]
+m.spoke_width     = ${model['spoke_width']*1e3}  -- Spoke width: >0 magn_width will be calculated
+m.gap_ma_yoke     = 0
+m.nodedist        = ${model.get('nodedist', 1)}
+--@param  m.npols_gen         -- Number of poles generated
+
+
+  if (m.model_type == "S2R1") or  (m.model_type == "S2R1_all") then
+    if (m.yoke_height > 0) then
+      m.yoke_height = 0
+      print("Warning: m.yoke_height for this typ must be 0. Set to 0!")
+    end
+  end
+
+  if (m.yoke_height > 0) then
+    mh = m.magn_height
+  else
+    mh = m.magn_height/2
+  end
+
+  if m.spoke_width > 0 then
+    m.magn_width = -(m.pole_width-m.spoke_width)
+  end
+  if m.magn_width > 0 then
+    mw = m.magn_width/100*m.pole_width
+  else
+    mw = -m.magn_width
+  end
+
+  fml = require("fml")
+
+  P0 = fml.Point:Create(0, -ag)
+
+  Lh1 = fml.Line:Create(P0,0)
+  Lh2 = fml.Line:Parallel(Lh1,mh)
+  Lh3 = fml.Line:Parallel(Lh2,m.yoke_height)
+
+  Lv1 = fml.Line:Create(P0,90)
+  Lv2 = fml.Line:Parallel(Lv1,(m.pole_width-mw)/2)
+  Lv3 = fml.Line:Parallel(Lv1,(m.pole_width+mw)/2)
+  Lv4 = fml.Line:Parallel(Lv1,m.pole_width)
+
+  P11 = P0
+  P12 = fml.Point:Intersection(Lh2,Lv1)
+  P13 = fml.Point:Intersection(Lh3,Lv1)
+  P21 = fml.Point:Intersection(Lh1,Lv2)
+  P22 = fml.Point:Intersection(Lh2,Lv2)
+  P31 = fml.Point:Intersection(Lh1,Lv3)
+  P32 = fml.Point:Intersection(Lh2,Lv3)
+  P41 = fml.Point:Intersection(Lh1,Lv4)
+  P42 = fml.Point:Intersection(Lh2,Lv4)
+  P43 = fml.Point:Intersection(Lh3,Lv4)
+
+  ndt(m.nodedist)
+
+  nc_line(P11.x,P11.y, P21.x,P21.y, 0)
+  nc_line_cont(P31.x,P31.y, 0)
+  nc_line_cont(P41.x,P41.y, 0)
+
+  nc_line(P12.x,P12.y, P22.x,P22.y, 0)
+  nc_line_cont(P32.x,P32.y, 0)
+  nc_line_cont(P42.x,P42.y, 0)
+
+  nc_line(P11.x,P11.y, P12.x,P12.y, 0)
+  nc_line(P21.x,P21.y, P22.x,P22.y, 0)
+  nc_line(P31.x,P31.y, P32.x,P32.y, 0)
+  nc_line(P41.x,P41.y, P42.x,P42.y, 0)
+
+  create_mesh_se((P12.x+P22.x)/2, (P11.y + P12.y)/2)
+  create_mesh_se((P22.x+P32.x)/2, (P21.y + P22.y)/2)
+  create_mesh_se((P32.x+P42.x)/2, (P31.y + P32.y)/2)
+
+  if (m.yoke_height > 0) then
+    nc_line(P13.x,P13.y, P43.x,P43.y, 0)
+    nc_line(P12.x,P12.y, P13.x,P13.y, 0)
+    nc_line(P42.x,P42.y, P43.x,P43.y, 0)
+    x,y = (P12.x+P42.x)/2,(P42.y+P43.y)/2
+    create_mesh_se(x,y)
+    def_new_sreg(x,y, "rofe", "blue")
+    if (mcvkey_yoke == 'dummy') then
+      def_mat_fm(x,y, blue, 1000, 100)
+    else
+      def_mat_fm_nlin(x,y, blue, mcvkey_yoke, 100, 0)
+    end
+  end
+
+  translate_copy_nodechains(P11.x,P11.y, P13.x,P13.y, P43.x,P43.y, P41.x,P41.y, m.npols_gen-1)
+
+  x = (P12.x+P32.x)/2
+  y = (P12.y+P32.y)/2
+  for i = 1,m.npols_gen do
+    if i%2 == 0 then
+      def_mat_pm(x,y, 'red', m.remanenc, m.relperm, 90, "parallel", 0, m.rlen)
+    else
+      def_mat_pm(x,y, 'green', m.remanenc, m.relperm, 270, "parallel", 0, m.rlen)
+    end
+    x = x + m.pole_width
+  end

femagtools/templates/afm_stator.mako

@@ -0,0 +1,141 @@
+--[[ Supported AFM Model Types
+"S1R1"      -- 1 stator, 1 rotor
+"S1R2"      -- 1 stator, 2 rotor, 1 half simulated
+"S1R2_all"  -- 1 stator, 2 rotor, all simulated
+"S2R1"      -- 2 stator, 1 rotor, 1 half simulated
+"S2R1_all"  -- 2 stator, 1 rotor, all simulated
+b--]]
+m.slot_height     =  ${model['slot_height']*1e3}    -- Total slot height [mm]
+m.slot_h1         =  ${model['slot_h1']*1e3}        -- Slot opening height [mm]
+m.slot_h2         =  ${model['slot_h2']*1e3}        -- Distance to radius [mm]
+m.st_yoke_height  =  ${model['yoke_height']*1e3} -- Yoke height [mm]
+m.slot_width      =  ${model['slot_width']*1e3}     -- Slot width [mm]
+m.slot_open_width =  ${model['slot_open_width']*1e3} -- Slot opening width [mm]
+m.slot_r1         =  ${model['slot_r1']*1e3}         -- Slot radius [mm]
+m.slot_r2         =  ${model['slot_r2']*1e3}         -- Slot radius [mm]
+m.mcvkey_yoke     =  mcvkey_yoke
+m.nodedist        =  ${model.get('m.nodedist', 1)}  -- Node distance
+
+  if (m.model_type == "S1R2") or  (m.model_type == "S1R2_all") then
+    if (m.st_yoke_height > 0) then
+      m.st_yoke_height = 0
+      print("Warning: m.st_yoke_height for this type must be 0. Set to 0!")
+    end
+  end
+
+  if m.st_yoke_height > 0 then
+    sh = m.slot_height
+  else
+    sh = m.slot_height/2
+  end
+
+  fml = require("fml")
+
+  P0 = fml.Point:Create(0,0)
+
+  Lh1 = fml.Line:Create(P0,0)
+  Lh2 = fml.Line:Parallel(Lh1,-m.slot_h1)
+  Lh3 = fml.Line:Parallel(Lh1,-m.slot_h2)
+  Lh4 = fml.Line:Parallel(Lh1,-(sh-m.slot_r2))
+  Lh5 = fml.Line:Parallel(Lh1,-sh)
+  Lh6 = fml.Line:Parallel(Lh1,-(sh+m.st_yoke_height))
+
+  Lv1 = fml.Line:Create(P0,90)
+  m.width_bz = m.pole_width*m.num_poles/m.tot_num_slot
+  m.tooth_width = m.width_bz-m.slot_width
+  Lv2 = fml.Line:Parallel(Lv1,m.tooth_width/2)
+  Lv3 = fml.Line:Parallel(Lv1,m.tooth_width/2+m.slot_r1)
+  Lv4 = fml.Line:Parallel(Lv1,m.tooth_width/2+m.slot_r2)
+  Lv5 = fml.Line:Parallel(Lv1,m.tooth_width/2+m.slot_width/2-m.slot_open_width/2)
+  Lv6 = fml.Line:Parallel(Lv1,m.tooth_width/2+m.slot_width/2)
+
+  P11 = P0
+  P16 = fml.Point:Intersection(Lh6,Lv1)
+  P23 = fml.Point:Intersection(Lh3,Lv2)
+  P24 = fml.Point:Intersection(Lh4,Lv2)
+  P25 = fml.Point:Intersection(Lh5,Lv2)
+  P26 = fml.Point:Intersection(Lh6,Lv2)
+  P34 = fml.Point:Intersection(Lh4,Lv3)
+  P33 = fml.Point:Intersection(Lh3,Lv3)
+  P44 = fml.Point:Intersection(Lh4,Lv4)
+  P45 = fml.Point:Intersection(Lh5,Lv4)
+  P51 = fml.Point:Intersection(Lh1,Lv5)
+  P52 = fml.Point:Intersection(Lh2,Lv5)
+  P61 = fml.Point:Intersection(Lh1,Lv6)
+  P62 = fml.Point:Intersection(Lh2,Lv6)
+  P65 = fml.Point:Intersection(Lh5,Lv6)
+  P66 = fml.Point:Intersection(Lh6,Lv6)
+
+  if (m.slot_r1 > 0) then
+    C1 = fml.Circle:Create(P33,m.slot_r1)
+    P32 = fml.Point:Tangent(P52,C1,2)
+  else
+    P32 = P23
+  end
+
+  model_size = m.pole_width*m.num_poles*m.num_slots/m.tot_num_slot
+  blow_up_wind(0,-model_size/2, model_size,model_size/2)
+  ndt(m.nodedist)
+
+  nc_line(P11.x,P11.y, P52.x,P51.y, 0)
+  nc_line_cont(P61.x,P61.y, 0)
+  nc_line(P52.x,P52.y, P62.x,P62.y, 0)
+  if (m.st_yoke_height > 0) then
+    nc_line(P45.x,P45.y, P65.x,P65.y, 0)
+    nc_line(P16.x,P16.y, P66.x,P66.y, 0)
+  else
+    nc_line(P16.x,P16.y, P26.x,P26.y, 0)
+    nc_line_cont(P66.x,P66.y, 0)
+  end
+
+  nc_line(P11.x,P11.y, P16.x,P16.y, 0)
+  if (m.st_yoke_height > 0) then
+    nc_line(P23.x,P23.y, P24.x,P24.y, 0)
+  else
+    nc_line(P23.x,P23.y, P26.x,P26.y, 0)
+  end
+  nc_line(P51.x,P51.y, P52.x,P52.y, 0)
+  nc_line(P61.x,P61.y, P62.x,P62.y, 0)
+  if (m.st_yoke_height > 0) then
+    nc_line_cont(P65.x,P65.y, 0)
+    nc_line_cont(P66.x,P66.y, 0)
+  else
+    nc_line_cont(P66.x,P66.y, 0)
+  end
+  nc_line(P52.x,P52.y, P32.x,P32.y, 0)
+
+  if (m.slot_r1 > 0) then
+    nc_circle_m(P23.x,P23.y, P32.x,P32.y, P33.x,P33.y, m.slot_r1, 0)
+  end
+  if (m.st_yoke_height > 0 and  m.slot_r2 > 0) then
+    nc_circle_m(P45.x,P45.y, P24.x,P24.y, P44.x,P44.y, m.slot_r2, 0)
+  end
+
+  if m.slot_h1 > 0 then
+    create_mesh_se((P51.x+P61.x)/2, (P51.y + P52.y)/2)
+  end
+  create_mesh_se((P23.x+P62.x)/2, (P62.y + P65.y)/2)
+
+  x,y = (P11.x+P26.x)/2,(P11.y+P26.y)/2
+  create_mesh_se(x, y)
+  def_new_sreg(x,y, "stfe", "blue")
+
+  x1,y1 = P61.x,P61.y
+  x2,y2 = P66.x,P66.y
+  mirror_nodechains(x1,y1, x2,y2)
+
+  x1,y1 = P16.x,P16.y
+  x2,y2 = P11.x,P11.y
+  x3,y3 = 2*P61.x,P61.y
+  x4,y4 = 2*P61.x,P66.y
+  translate_copy_nodechains(x1,y1, x2,y2, x3,y3, x4,y4,
+                  m.num_sl_gen-1)
+
+  x,y = (P11.x+P26.x)/2,(P11.y+P26.y)/2
+  if (m.mcvkey_yoke == 'dummy') then
+    def_mat_fm(x,y, blue, 1000, 100)
+  else
+    def_mat_fm_nlin(x,y, blue, m.mcvkey_yoke, 100, 0)
+  end
+
+  m.middle_line     = 1  -- vertical slot parts

femagtools/templates/airgapinduc.mako

@@ -1,6 +1,6 @@
-  post_models("induct(x)","b")    -- Calculate field distribution
+  post_models("induct(x)","bagx")    -- Calculate field distribution
   data=io.open("bag.dat","w")     -- Output in data file
-  for i = 1, table.getn(b), 3 do
-    data:write(string.format("%g %g %g\n",b[i],b[i+1],b[i+2]))
+  for i = 1, #bagx, 3 do
+    data:write(string.format("%g %g %g\n",bagx[i],bagx[i+1],bagx[i+2]))
   end
   io.close(data)

femagtools/templates/basic_modpar.mako

@@ -14,6 +14,7 @@ ag = 0
 % if model.move_action == 0:
 % if model.external_rotor:
 dy2 = ${model.get(['outer_diam'])*1e3}
+% if hasattr(model, 'bore_diam'):
 % if isinstance(model.get(['bore_diam']), list):
 <%
 da2 = '{' + ','.join([str(x*1e3) for x in model.get(['bore_diam'])]) +'}'
@@ -27,9 +28,11 @@ end
 da2 = ${model.get(['bore_diam'])*1e3}
 da1 = da2 - 2*ag
 % endif
+% endif # bore_diam dos not exist
 dy1 = ${model.get(['inner_diam'])*1e3}
 % else: # internal rotor
 dy1 = ${model.get(['outer_diam'])*1e3}
+% if hasattr(model, 'bore_diam'):
 % if isinstance(model.get(['bore_diam']), list):
 <%
 da1 = '{' + ','.join([str(x*1e3) for x in model.get(['bore_diam'])]) +'}'
@@ -43,6 +46,7 @@ end
 da1 = ${model.get(['bore_diam'])*1e3}
 da2 = da1 - 2*ag
 % endif
+% endif
 % if hasattr(model, 'shaft_diam'):
 dy2 = ${model.get(['shaft_diam'])*1e3}
 dsh = ${model.get(['inner_diam'])*1e3}
@@ -66,7 +70,8 @@ m.num_pol_pair    =   m.num_poles/2
 m.num_slots       =   m.num_sl_gen
 m.npols_gen       =   m.num_poles * m.num_sl_gen / m.tot_num_slot
 m.tot_num_sl      =   m.tot_num_slot
-% if model.move_action == 0:
+% if model.move_action == 0:  # rotating
+% if hasattr(model, 'bore_diam'):
 % if isinstance(model.get(['bore_diam']), list):
 m.fc_radius       =   (da1[2]/2-ag[2]/2) -- Radius airgap (extern)
 m.fc_radius1      =   (da1[1]/2-ag[1]/2) -- Radius airgap (intern?)
@@ -77,10 +82,26 @@ m.fc_radius1      =   m.fc_radius
 m.sl_radius       =   m.fc_radius      -- radius of sliding area
 % endif
 % endif
+% elif hasattr(model, 'pole_width'):  # move action linear
+m.pole_width      = ${model['pole_width']*1e3}
+% endif
+% if hasattr(model, 'lfe'):
 m.arm_length      =   ${model.get(['lfe'])*1e3}
+% endif
 pre_models("basic_modpar")
 % endif
 % if hasattr(model, 'num_agnodes'):
-num_agnodes = ${model.num_agnodes}
+num_agnodes = m.npols_gen*${model.num_agnodes}
+% if hasattr(model, 'bore_diam'):
 agndst = 2*math.pi*m.fc_radius/num_agnodes
+% else:
+if m.pole_width ~= nil then
+  agndst = 2*m.pole_width/num_agnodes
+else
+  agndst = 1 -- last resort
+end
+% endif
 % endif
+% if hasattr(model, 'afmtype'):
+m.model_type      =  "${model['afmtype']}"
+% endif

femagtools/templates/cogg_calc.mako

@@ -1,19 +1,42 @@
 --
 -- Cogging
 --
-m.move_action     =    0.0 -- rotate
 % if model.get('lfe', 0):
 m.arm_length      =    ${model.get('lfe')*1e3}
 % endif
-
+m.move_action     =    ${model.get('move_action', 0)}
+% if model.get('move_action', 0) == 0:
 m.speed           =    ${model.get('speed')*60}
 m.skew_angle      =    ${model.get('skew_angle', 0)}
+m.fc_force_points   =  0.0 --    number move points in air gap
+m.phi_start       =    ${model.get('phi_start', 0)}
+m.range_phi       =    ${model.get('range_phi', 0)}
+% else:
+m.speed_linear    =    ${model.get('speed')}
+m.skew_linear     =    ${model.get('skew_displ',0)}
+m.line            =    0
+m.two_pole_wi     =    2*m.pole_width
+m.range_x         =    m.two_pole_wi
+m.range_y         =    0.0
+
+m.fc_force_points =  5
+m.fcpx_mm1        =   m.npols_gen*m.pole_width +1.0
+m.fcpy_mm1        =   -ag/2
+m.fcpx_mm2        =   -1.0
+m.fcpy_mm2        =   m.fcpy_mm1
+m.fcpx_mm3        =   m.fcpx_mm2
+m.fcpy_mm3        =   -m.magn_height -m.yoke_height -m.gap_ma_yoke -1 -ag
+m.fcpx_mm4        =   m.fcpx_mm1
+m.fcpy_mm4        =   m.fcpy_mm3
+m.fcpx_mm5        =   m.fcpx_mm1
+m.fcpy_mm5        =   m.fcpy_mm1
+
+--m.npols_gen       =  1 -- number of sectors simulated
+% endif
+
 m.nu_skew_steps   =    ${model.get('num_skew_steps', 0)}
 m.magn_temp       =    ${model.get('magn_temp')}
 m.fc_mult_move_type =  1.0 --  Type of move path in air gap
-m.fc_force_points   =  0.0 --    number move points in air gap       
-m.phi_start       =    ${model.get('phi_start', 0)}
-m.range_phi       =    ${model.get('range_phi', 0)}
 m.nu_move_steps   =    ${model.get('num_move_steps', 49)}
 
 m.num_par_wdgs    =    ${model.get('num_par_wdgs',1)}