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

femagtools/dxfsl/machine.py

@@ -713,21 +713,98 @@ class Machine(object):
     def delete_tiny_elements(self, mindist):
         self.geom.delete_tiny_elements(mindist)
 
+    def create_arc(self, radius):
+        arc = Arc(Element(center=self.center,
+                          radius=radius,
+                          start_angle=(self.startangle-0.1)*180/np.pi,
+                          end_angle=(self.endangle+0.1)*180/np.pi),
+                  color='red')
+        pts = self.geom.split_and_get_intersect_points(arc)
+        if len(pts) != 2:
+            logger.warning("create_arc(): Bad Points: %s", pts)
+            # self.geom.add_edge(arc.node1(4), arc.node2(4), arc)
+            return False
+
+        arc = Arc(Element(center=self.center,
+                          radius=radius,
+                          start_angle=self.startangle*180/np.pi,
+                          end_angle=self.endangle*180/np.pi))
+        n = self.geom.find_nodes(pts[0], pts[1])
+        self.geom.add_edge(n[0], n[1], arc)
+        return True
+
+    def get_iron_separator(self, radius_list):
+        if len(radius_list) < 2:
+            return 0.0
+
+        r_min = radius_list[0][0]
+        for r in radius_list[1:]:
+            if np.isclose(r[2], r_min, atol=0.001):
+                return r[2]
+            r_min = r[0]
+
+        return 0.0
+
     def create_mirror_lines_outside_windings(self):
+        logger.debug("create_mirror_lines_outside_windings")
+
         if not self.geom.has_areas_touching_both_sides():
+            logger.debug("end create_mirror_lines_outside_windings: not done")
             return
 
+        radius = self.radius+10
+        ag_list = self.geom.detect_airgaps(self.center,
+                                           self.startangle, self.endangle,
+                                           atol=0.001,
+                                           with_end=True)
+        radius_list = [(ag[0], (ag[0] + ag[1]) / 2, ag[1]) for ag in ag_list]
+        radius_list.sort(reverse=True)
+
         midangle = middle_angle(self.startangle, self.endangle)
-        pts = self.geom.split_and_get_intersect_points(self.center,
-                                                       self.radius+10,
-                                                       midangle)
+        line = Line(
+            Element(start=self.center,
+                    end=point(self.center, radius, midangle)))
+
+        pts = self.geom.split_and_get_intersect_points(line, aktion=False)
         pts.sort()
+
+        p_critical = self.geom.critical_touch_point(pts)
+        if p_critical:
+            d_critical = distance(self.center, p_critical)
+            logger.info("Critical Point: %s, len=%s", p_critical, d_critical)
+            sep_radius = self.get_iron_separator(radius_list)
+            logger.debug("Iron Separator found: %s", sep_radius)
+            if sep_radius > 0.0 and sep_radius < d_critical:
+                radius = sep_radius
+            else:
+                for r in radius_list:
+                    logger.debug("Gap Radius = %s", r[1])
+                    if r[1] < d_critical:
+                        if self.create_arc(r[1]):
+                            radius = r[1]
+                        break
+#        else:
+#            sep_radius = self.get_iron_separator(radius_list)
+#            if sep_radius > 0.0:
+#                logger.debug("Iron Separator found: %s", sep_radius)
+#                radius = sep_radius
+
+        # install line
+        line = Line(
+            Element(start=self.center,
+                    end=point(self.center, radius, midangle)))
+
+        pts = self.geom.split_and_get_intersect_points(line)
+        pts.sort()
+
         if self.geom.create_lines_outside_windings(pts):
             self.geom.area_list = []
             logger.debug("create subregions again")
             self.geom.create_list_of_areas()
             self.geom.search_subregions()
 
+        logger.debug("end create_mirror_lines_outside_windings")
+
     def check_and_correct_geom(self, what):
         geom = self.geom.check_geom(what)
         if geom:

femagtools/ecloss.py

@@ -115,7 +115,7 @@ class MagnLoss(Amela):
         self.tgrid = 60/self.speed*(self.theta[-1] - self.theta[0])/360
         self.lt = len(self.theta)
         self.ls = self.pm[-1][-1]['ls']
-
+        self.th_loss = []
         try:
             self.numpoles = self.pm[-1][-1]['numpoles']
         except KeyError: 
@@ -351,7 +351,7 @@ class MagnLoss(Amela):
                                 with warnings.catch_warnings():
                                     warnings.simplefilter('ignore')
                                     px_se[iy,ix,c] = self.calc_pvpm(bx_fft[iy,ix,c], max(c/self.tgrid, 1e-6),
-                                                                    mu[iy], wm/self.segx[jj], hm, 0)
+                                                                    mu[iy], hm, wm/self.segx[jj], 0)
                                 
                             if mu[iy] < 2:
                                 with warnings.catch_warnings():
@@ -374,6 +374,7 @@ class MagnLoss(Amela):
         all_load_cases = []
         for k in self.pm:
             ialh_loss = 0
+            loss_detail = []
             for i in k: 
                 logger.info(f'magnet width and height: {i["wm"]:.2f}mm {i["hm"]:.2f}mm')
                 [nt, bx_fft, by_fft] = self.periodicity_id(i['bl'])
@@ -383,9 +384,10 @@ class MagnLoss(Amela):
                     i[j]*=1e-3
                 self.consider_bx(i['wm'], i['hm'], bx_fft, by_fft)
                 bfft = self.bpm_fft(nx, ny, nt, i['elcp'], i['bl'])
-                #loss = self.loss(bfft[0], bfft[1], bfft[2], bfft[3], i['wm'], i['hm'])
                 loss = self.loss(*bfft, i['wm'], i['hm'])
                 ialh_loss += loss
+                loss_detail.append([i['spel_key'], loss/self.numpoles])
+            self.th_loss.append(loss_detail)
             all_load_cases.append(ialh_loss)
 
         return all_load_cases

femagtools/femag.py

@@ -492,7 +492,8 @@ class Femag(BaseFemag):
                 return {'t': ttemp[0], 'temperature': ttemp[1]}
 
             bch = self.read_bch(self.modelname)
-            if simulation['calculationMode'] == 'pm_sym_fast':
+            if simulation['calculationMode'] == 'pm_sym_fast' or \
+                simulation['calculationMode'] == 'torq_calc':
                 if simulation.get('shortCircuit', False):
                     logger.info("short circuit simulation")
                     simulation.update(
@@ -550,6 +551,11 @@ class Femag(BaseFemag):
                         bch.losses[i].update({"magnetH": magn_losses[i]})
                 except: 
                     pass
+                # pass losses to bch object for th usage
+                try: 
+                    bch.magnet_loss_th = m.th_loss
+                except: 
+                    pass
             return bch
         return dict(status='ok', message=self.modelname)
 

femagtools/isa7.py

@@ -196,7 +196,9 @@ class Reader(object):
             self.el_fe_induction_1.append([[]])
             self.el_fe_induction_2.append([[]])
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
-                self.el_fe_induction_1[0][0].append(self.next_block("h"))
+                b = self.next_block("h")
+                logger.debug("el_fe_induction move step %d: %d", i, len(b))
+                self.el_fe_induction_1[0][0].append(b)
                 self.el_fe_induction_2[0][0].append(self.next_block("h"))
 
         FC_NUM_MOVE_CALC_LOAD_PMS, FC_NUM_FLX = self.next_block("i")[0:2]
@@ -270,7 +272,9 @@ class Reader(object):
             self.el_fe_induction_2.append([[]])
             self.eddy_cu_vpot.append([[]])
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
-                self.el_fe_induction_1[1][0].append(self.next_block("h"))
+                b = self.next_block("h")
+                logger.debug("el_fe_induction move losses step %d: %d", i, len(b))
+                self.el_fe_induction_1[1][0].append(b)
                 self.el_fe_induction_2[1][0].append(self.next_block("h"))
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
                 self.eddy_cu_vpot[1][0].append(self.next_block("h"))
@@ -335,7 +339,10 @@ class Reader(object):
             self.el_fe_induction_2.append([[]])
             self.eddy_cu_vpot.append([[]])
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
-                self.el_fe_induction_1[2][0].append(self.next_block("h"))
+                b = self.next_block("h")
+                logger.debug("el_fe_induction move losses (2) step %d: %d",
+                            i, len(b))
+                self.el_fe_induction_1[2][0].append(b)
                 self.el_fe_induction_2[2][0].append(self.next_block("h"))
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
                 self.eddy_cu_vpot[2][0].append(self.next_block("h"))
@@ -688,25 +695,31 @@ class Isa7(object):
             self.curr_loss = np.array([c/np.sqrt(2) for c in reader.curr_loss])
         except AttributeError:
             pass
-        logger.debug(reader.el_fe_induction_1)
-        if len(np.asarray(reader.el_fe_induction_1).shape) > 2:
-            self.el_fe_induction_1 = np.asarray(
-                reader.el_fe_induction_1).T/1000
-            self.el_fe_induction_2 = np.asarray(
-                reader.el_fe_induction_2).T/1000
-            self.eddy_cu_vpot = np.asarray(reader.eddy_cu_vpot).T/1000
-        else:
-            try:
-                self.el_fe_induction_1 = np.asarray(
-                    [e for e in reader.el_fe_induction_1 if e[0]]).T/1000
-                self.el_fe_induction_2 = np.asarray(
-                    [e for e in reader.el_fe_induction_2 if e[0]]).T/1000
-                self.eddy_cu_vpot = np.asarray(
-                    [e for e in reader.eddy_cu_vpot if e[0]]).T/1000
-                logger.debug('El Fe Induction %s', np.asarray(
-                    reader.el_fe_induction_1).shape)
-            except:
-                pass
+
+        try:
+            el_fe_ind = [np.array(reader.el_fe_induction_1).T/1000,
+                         np.array(reader.el_fe_induction_2).T/1000]
+            eddy_cu_vpot = np.array(reader.eddy_cu_vpot).T/1000
+        except (ValueError, TypeError) as e:
+            # inhomogenous array
+            l = len(reader.el_fe_induction_1[0][0])
+            shape = []
+            for i in reader.el_fe_induction_1:
+                for j in i:
+                    n = 0
+                    for k in j:
+                        if len(k) < l:
+                            break
+                        n += 1
+                    if n > 0:
+                        shape.append(n)
+            el_fe_ind = [np.array([[reader.el_fe_induction_1[0][0][:shape[0]]]]).T/1000,
+                         np.array([[reader.el_fe_induction_2[0][0][:shape[0]]]]).T/1000]
+            eddy_cu_vpot = np.array([[reader.eddy_cu_vpot[0][0][:shape[0]]]]).T/1000
+
+        self.el_fe_induction_1 = el_fe_ind[0]
+        self.el_fe_induction_2 = el_fe_ind[1]
+        self.eddy_cu_vpot = eddy_cu_vpot
 
         self.iron_loss_coefficients = getattr(
             reader, 'iron_loss_coefficients', [])

femagtools/machine/effloss.py

@@ -269,7 +269,10 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         u1 = np.array(r['u1'])
         i1 = np.array(r['i1'])
         try:
-            tfric = eecpars['kfric_b']*eecpars['rotor_mass']*30e-3/np.pi
+            if isinstance(eecpars, dict):
+                tfric = eecpars['kfric_b']*eecpars['rotor_mass']*30e-3/np.pi
+            else:
+                tfric = m.tfric
         except KeyError:
             tfric = 0
 

femagtools/machine/utils.py

@@ -346,6 +346,7 @@ def dqparident(workdir, engine, temp, machine,
     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)
+    cmd: femag executable
     """
     import pathlib
 
@@ -368,13 +369,16 @@ def dqparident(workdir, engine, temp, machine,
         period_frac = 1  # TODO: missing femag support
 
     # winding resistance
-    yd = machine['windings'].get('coil_span', Q1/machine['poles'])
-    wdg = windings.Winding(
-        {'Q': machine['stator']['num_slots'],
-         'm': machine['windings']['num_phases'],
-         'p': machine['poles']//2,
-         'l': machine['windings']['num_layers'],
-         'yd': yd})
+    wpar = {'Q': machine['stator']['num_slots'],
+            'm': machine['windings']['num_phases'],
+            'p': machine['poles']//2}
+
+    if 'coil_span' in machine['windings']:
+        wpar['yd'] = machine['windings']['coil_span']
+    if 'num_layers' in machine['windings']:
+        wpar['l'] = machine['windings']['num_layers']
+
+    wdg = windings.Winding(wpar)
 
     lfe = machine['lfe']
     g = machine['windings'].get('num_par_wdgs', 1)
@@ -401,7 +405,7 @@ def dqparident(workdir, engine, temp, machine,
     parvar = parstudy.List(
         workdir, condMat=condMat,
         magnetizingCurves=magnetizingCurves,
-        magnets=magnetMat)
+        magnets=magnetMat, cmd=kwargs.get('cmd', None))
 
     leakfile = pathlib.Path(workdir) / 'end_wind_leak.dat'
     leakfile.unlink(missing_ok=True)

femagtools/model.py

@@ -11,6 +11,7 @@
 import logging
 import string
 import numpy as np
+from . import windings
 
 logger = logging.getLogger(__name__)
 #
@@ -156,8 +157,17 @@ class MachineModel(Model):
             for mcv in ('mcvkey_yoke', 'mcvkey_shaft'):
                 if mcv not in self.magnet:
                     self.magnet[mcv] = 'dummy'
-        if 'coord_system' in parameters:
+        if 'coord_system' in parameters or 'afmtype' in parameters:
             self.move_action = 1
+            wdg = windings.Winding({'Q': self.stator['num_slots'],
+                                    'p': self.poles//2,
+                                    'm': self.windings.get('num_phases', 3),
+                                    'l': self.windings.get('num_layers', 1)})
+            self.windings['wdgscheme'] = ''.join([
+                '{'] + [','.join([''.join(['{']+[','.join([''.join([
+                    '{', ','.join(
+                        [str(n) for n in z]), '}']) for z in l])] + ['}'])
+                                  for l in wdg.zoneplan()])] + ['}'])
         else:
             self.coord_system = 0
             self.move_action = 0

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))
@@ -1344,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]
 
@@ -1774,7 +1778,7 @@ def get_nT_boundary(n, T):
     bnd[1].append((nx, tx))
     return np.array(bnd[0] + bnd[1][::-1])
 
-def normalize10(v):
+def normalize10(v, **kwargs):
     """
     Normalizes the input-array using the nearest (ceiling) power of 10.
 
@@ -1785,12 +1789,32 @@ def normalize10(v):
         normalized array
         normalisation factor (power of 10)
     """
-    norm = 10**(np.ceil(np.log10(np.max(np.abs(v)))))
+    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):
+                 clabel=True, cmap='YlOrRd', cbar=False, **kwargs):
     """ contour plot of speed, torque, z values
     Arguments:
     levels: (list of floats)
@@ -1807,8 +1831,8 @@ def plot_contour(speed, torque, z, ax, title='', levels=[],
     x = 60*np.asarray(speed)
     y = np.asarray(torque)
 
-    x, xscale = normalize10(x)
-    y, yscale = normalize10(y)
+    x, xscale = normalize10(x, **kwargs)
+    y, yscale = normalize10(y, **kwargs)
 
     if not levels:
         if max(z) <= 1:

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