femagtools 1.8.12__py3-none-any.whl → 1.8.13__py3-none-any.whl

femagtools/machine/sm.py

@@ -42,8 +42,8 @@ def parident(workdir, engine, machine,
 
         optional arguments:
         num_cur_steps: number of current steps (default 5)
-        num_beta_steps: number of current steps (default 13)
-        num_exc_steps: number of excitation current (default 7)
+        num_beta_steps: number of beta steps (default 13)
+        num_exc_steps: number of excitation current (default 6)
         speed: rotor speed in 1/s (default 160/p)
         i1_max: maximum current in A rms (default approx 3*i1nom)
         beta_min: minimal current angle (default -180°)
@@ -79,9 +79,14 @@ def parident(workdir, engine, machine,
     exc_logspace = True
     ifmin, ifmax = ifnom/4, 1.4*ifnom
     if exc_logspace:
-        excur = np.logspace(np.log(ifmin), np.log(ifmax),
+        """excur = np.logspace(np.log(ifmin), np.log(ifmax),
                             kwargs.get("num_exc_steps", 6),
-                            base=np.exp(1)).tolist()
+                            base=np.exp(1)).tolist()"""
+        # create a data grid always contains ifnom
+        excur = np.logspace(np.log(ifmin), np.log(ifnom),
+                            kwargs.get("num_exc_steps", 6) - 2,
+                            base=np.exp(1), endpoint=False).tolist()
+        excur.extend([ifnom, ifmax])
     else:
         excur = np.linspace(ifmin, ifmax,
                             kwargs.get("num_exc_steps", 6))
@@ -440,10 +445,6 @@ class SynchronousMachine(object):
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                return pcu
-
             res = so.minimize(
                 self.culoss, startvals, method='SLSQP',  # trust-constr
                 bounds=self.bounds,
@@ -469,10 +470,6 @@ class SynchronousMachine(object):
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                #logger.info("iqde %s --> pcu %f", iqde, pcu)
-                return pcu
             res = so.minimize(
                 self.culoss, startvals, method='SLSQP',  # trust-constr
                 bounds=self.bounds,
@@ -513,42 +510,38 @@ class SynchronousMachine(object):
          with minimal losses at max voltage"""
         iqde = self.iqd_tmech(torque, w1/2/np.pi/self.p)
         if np.linalg.norm(
-                self.uqd(w1, *iqde)) <= u1max*np.sqrt(2):
+            self.uqd(w1, *iqde)) <= u1max*np.sqrt(2):
             if log:
                 log(iqde)
             return (*iqde, torque)
-        #beta, i1 = betai1(iqde[0], iqde[1])
-        #iex = iqde[2]
-
-        #beta = 0 if torque>0 else np.pi
-        io = iqde[0], 0, iqde[2] #*iqd(beta, i1), iex
+        beta, i1 = betai1(iqde[0], iqde[1])
+        iex = iqde[2]
+        def ubeta(b):
+            return np.sqrt(2)*u1max - np.linalg.norm(
+                         self.uqd(w1, *iqd(b, i1), iex))
+        beta = -np.pi/4 if torque>0 else -3*np.pi/4
+        io = *iqd(beta, i1), iex
 
         #    logger.debug("--- torque %g io %s", torque, io)
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            n = w1/2/np.pi/self.p
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                #logger.info("iqde %s pcu %g", iqde, pcu)
-                return pcu
-
-            res = so.minimize(
-                self.culoss, io, method='SLSQP',  # trust-constr
-                bounds=self.bounds,
-                constraints=[
-                    {'type': 'eq',
-                     'fun': lambda iqd: torque - self.tmech_iqd(*iqd, n)},
-                    {'type': 'eq',
-                     'fun': lambda iqd: u1max*np.sqrt(2)
-                       - np.linalg.norm(self.uqd(w1, *iqd))}])
-            #if res['success']:
-            if log:
-                log(res.x)
+        n = w1/2/np.pi/self.p
+        res = so.minimize(
+            self.culoss, io, method='SLSQP',  # trust-constr
+            bounds=self.bounds,
+            constraints=[
+                {'type': 'eq',
+                 'fun': lambda iqd: self.tmech_iqd(*iqd, n) - torque},
+                {'type': 'eq',
+                 'fun': lambda iqd: np.linalg.norm(
+                     self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}])
+
+        if log:
+            log(res.x)
+        if res["success"]:
             return *res.x, self.tmech_iqd(*res.x, n)
-        #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-        #               res['message'], w1, torque, u1max, io)
-        #raise ValueError(res['message'])
-        #return [float('nan')]*4
+
+        logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+                       res['message'], w1, torque, u1max, io)
+        raise ValueError(res['message'])
 
     def iqd_torque_umax(self, torque, w1, u1max,
                         disp=False, maxiter=500, log=0, **kwargs):
@@ -559,33 +552,31 @@ class SynchronousMachine(object):
                 if log:
                     log(iqde)
                 return (*iqde, torque)
-        io = iqde[0], 0, iqde[2]
-        #    logger.debug("--- torque %g io %s", torque, io)
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                #logger.info("iqde %s pcu %g", iqde, pcu)
-                return pcu
-
-            res = so.minimize(
-                self.culoss, io, method='SLSQP',  # trust-constr
-                bounds=self.bounds,
-                #options={'disp': disp, 'maxiter': maxiter},
-                #            jac=gradient_respecting_bounds(self.bounds, self.culoss),
-                constraints=[
-                    {'type': 'eq',
-                     'fun': lambda iqd: self.torque_iqd(*iqd) - torque},
-                    {'type': 'eq',
-                     'fun': lambda iqd: u1max*np.sqrt(2) - np.linalg.norm(
-                         self.uqd(w1, *iqd))}])
-            #if res['success']:
-            if log:
-                log(res.x)
+        beta, i1 = betai1(iqde[0], iqde[1])
+        iex = iqde[2]
+        def ubeta(b):
+            return np.sqrt(2)*u1max - np.linalg.norm(
+                         self.uqd(w1, *iqd(b, i1), iex))
+        beta = -np.pi/4 if torque>0 else -3*np.pi/4
+        io = *iqd(beta, i1), iex
+        res = so.minimize(
+            self.culoss, io, method='SLSQP',  # trust-constr
+            bounds=self.bounds,
+            #options={'disp': disp, 'maxiter': maxiter},
+            #            jac=gradient_respecting_bounds(self.bounds, self.culoss),
+            constraints=[
+                {'type': 'eq',
+                 'fun': lambda iqd: self.torque_iqd(*iqd) - torque},
+                {'type': 'eq',
+                 'fun': lambda iqd: u1max*np.sqrt(2) - np.linalg.norm(
+                     self.uqd(w1, *iqd))}])
+        if log:
+            log(res.x)
+        if res['success']:
             return *res.x, self.torque_iqd(*res.x)
-            #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-            #               res['message'], w1, torque, u1max, io)
-            #raise ValueError(res['message'])
+        logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+                       res['message'], w1, torque, u1max, io)
+        raise ValueError(res['message'])
 
     def w1_imax_umax(self, i1max, u1max):
         """return frequency w1 and shaft torque at voltage u1max and current i1max
@@ -669,10 +660,12 @@ class SynchronousMachine(object):
 
         wmtab = []
         dw = 0
+        wmMax = 2*np.pi*n
+        '''
         wmMax = 5*wmType
         if n > 0:
             wmMax = min(wmMax, 2*np.pi*n)
-
+        '''
         if wmType > wmMax:
             wmrange = sorted([0, wmMax])
             wmtab = np.linspace(0, wmMax, nsamples).tolist()
@@ -793,6 +786,7 @@ class SynchronousMachinePsidq(SynchronousMachine):
         self.psiqf = ip.RegularGridInterpolator(
             (exc, iqx, idx), psiq,
             method='cubic', bounds_error=False, fill_value=None)
+        # excitation currents bounds should respect ifnom
         self.bounds = [(min(iq), max(iq)),
                        (min(id), 0),
                        (iexc[0], iexc[-1])]
@@ -909,6 +903,7 @@ class SynchronousMachineLdq(SynchronousMachine):
             method='cubic'
             , bounds_error=False, fill_value=None)
         i1max = np.sqrt(2)*(max(i1))
+        # excitation currents bounds should respect ifnom
         self.bounds = [(np.cos(min(beta))*i1max, i1max),
                        (-i1max, 0),
                        (iexc[0], iexc[-1])]

femagtools/parstudy.py

@@ -140,7 +140,8 @@ class ParameterStudy(object):
 
     def __call__(self, opt, machine, simulation,
                  engine, bchMapper=None,
-                 extra_files=[], num_samples=0):
+                 extra_files=[], num_samples=0,
+                 data_model_created=False):
         """calculate objective vars for all decision vars
         Args:
           opt: variation parameter dict (decision_vars, objective_vars)
@@ -150,6 +151,8 @@ class ParameterStudy(object):
           bchMapper: bch result transformation function
           extra_files: list of additional input file names to be copied
           num_samples: number of samples (ingored with Grid sampling)
+          data_model_created: model and complete data structur
+                              was already created before calling this function
         """
 
         self.stop = False  # make sure the calculation will start. thomas.maier/OSWALD
@@ -174,7 +177,8 @@ class ParameterStudy(object):
             workdir = pathlib.Path(self.femag.workdir)
         for d in workdir.glob('[0-9]*'):
             if re.search(r'^\d+$', d.name):
-                shutil.rmtree(d)
+                if not data_model_created:
+                    shutil.rmtree(d)
 
         extra_result_files = []
         if simulation.get('airgap_induc', False):
@@ -198,8 +202,7 @@ class ParameterStudy(object):
 
         prob = femagtools.moproblem.FemagMoProblem(decision_vars,
                                                    objective_vars)
-
-        if immutable_model:
+        if not data_model_created and immutable_model:
             modelfiles = self.setup_model(builder, model, recsin=fea.recsin,
                                           feloss=simulation.get('feloss', ''))
             logger.info("Files %s", modelfiles+extra_files)
@@ -282,7 +285,7 @@ class ParameterStudy(object):
                 task = job.add_task(self.result_func)
                 for fn in extra_files:
                     task.add_file(fn)
-                if immutable_model:
+                if not data_model_created and immutable_model:
                     prob.prepare(x, [fea, self.femag.magnets])
                     for m in modelfiles:
                         task.add_file(m)
@@ -297,18 +300,21 @@ class ParameterStudy(object):
                 else:
                     prob.prepare(x, [model, fea, self.femag.magnets])
                     logger.info("prepare %s", x)
-                    for mc in self.femag.copy_magnetizing_curves(
-                            model,
-                            dir=task.directory,
-                            recsin=fea.recsin,
-                            feloss=feloss):
-                        task.add_file(mc)
-                    set_magnet_properties(model, fea, self.femag.magnets)
+                    if not data_model_created:
+                        for mc in self.femag.copy_magnetizing_curves(
+                                model,
+                                dir=task.directory,
+                                recsin=fea.recsin,
+                                feloss=feloss):
+                            task.add_file(mc)
+                        set_magnet_properties(model, fea, self.femag.magnets)
                     task.add_file(
                         'femag.fsl',
-                        builder.create_model(model, self.femag.magnets) +
+                        builder.create_model(model, self.femag.magnets) if not data_model_created else [] +
                         builder.create_analysis(fea) +
-                        ['save_model("close")'])
+                        ['save_model("close")'],
+                        append=data_model_created  # model already created, append fsl
+                    )
 
                 if hasattr(fea, 'poc'):
                     task.add_file(fea.pocfilename,

femagtools/plot/bch.py

@@ -559,7 +559,7 @@ def demagnetization(demag, ax=0):
     #        arrowprops=dict(facecolor='green', edgecolor='green', shrink=0.05))
     ax.set_ylim([rrmin, 1.01])
     ax.set_ylabel('Rel. Remanence')
-    ax.set_xlabel(f'Phase Current / {unit}')
+    ax.set_xlabel(f'Phase Current / {unit} (peak)')
     ax.grid()
 
 

femagtools/shortcircuit.py

@@ -112,12 +112,17 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
                                for d in bchsc.demag if 'H_max' in d],
                      'H_av': [d['H_av']
                               for d in bchsc.demag if 'H_av' in d]}
-                i1max = bchsc.scData['iks']
-                if dd['displ']:
-                    phi = dd['displ'][0]/180*np.pi
+                x1 = bchsc.demag[0]['current_1']
+                x2 = bchsc.demag[0]['current_2']
+                def func(phi):
+                    return x2*np.cos(phi) - x1*np.cos(phi-2*np.pi/3)
+                phi=so.fsolve(func, 0)[0]
+                i1max = x1/np.cos(phi)
+
+                phirot = dd['displ'][0]/180*np.pi
                 bchsc.scData['demag'] = demag(
                     femag, machine, simulation,
-                    i1max, phi, engine)
+                    i1max, phirot, phi, engine)
                 bchsc.scData['demag'].update(dd)
             scdata = bchsc.scData
             #for w in bch.flux:
@@ -310,7 +315,7 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
 
     # rotor position at maximum current:
     trot = min(iav[0], iap[0])
-    phi = wm*trot + phi0
+    phirot = wm*trot + phi0
     logger.info("phi %.1f")
 
     scData = {
@@ -330,10 +335,10 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
     if simulation.get('sim_demagn', 0):
         i1max = iap[1] if iap[1] > abs(iav[1]) else iav[1]
         scData['demag'] = demag(femag, machine, simulation,
-                                i1max, phi, engine)
+                                i1max, phirot, 0, engine)
     return scData
 
-def demag(femag, machine, simulation, i1max, phi, engine=0):
+def demag(femag, machine, simulation, i1max, phirot, phi, engine=0):
     """demag simulation using psi-torq-rem-rot"""
     logger.info("Demagnetization processing")
     i1min = simulation.get('i1min', abs(i1max/3))
@@ -345,7 +350,8 @@ def demag(femag, machine, simulation, i1max, phi, engine=0):
     i1tab = b*(a+np.log(xtab))
 
     if simulation.get('sc_type', 3) == 3:
-        curvec = [[-a/2, a, -a/2] for a in i1tab]
+        curvec = [[a*np.cos(phi), a*np.cos(phi-2*np.pi/3),
+                   a*np.cos(phi+2*np.pi/3)] for a in i1tab]
     else:
         if i1max > 0:
             curvec = [[a, -a, 0] for a in i1tab]
@@ -353,7 +359,7 @@ def demag(femag, machine, simulation, i1max, phi, engine=0):
             curvec = [[-a, a, 0] for a in i1tab]
     simulation.update({
         'calculationMode': 'psi-torq-rem',
-        'phi': phi,
+        'phi': phirot,
         'magntemp': simulation['Tmag'],
         'curvec': curvec})
     _ = femag(machine, simulation)

femagtools/templates/ec-rotorbar.mako

@@ -6,7 +6,8 @@ muer = 1
 rel = 100
 cur = {1, 0}
 sigma1, sigma2 = get_dev_data( "cond_conduct" )
-rotorbar = def_new_bar(xb,yb, "green", "U", cur[1],cur[2], "wi",
+--rotorbar = def_new_bar(xb,yb, "green", "U", cur[1],cur[2], "wi",
+rotorbar = def_new_bar(xcoil,ycoil, "green", "U", cur[1],cur[2], "wi", -- xcoil and ycoil defined in rotor_winding_ks2.mako
                        sigma2, muer, rel, "polar", 0, 0)
 Abar = get_sreg_data("area",rotorbar)
 

femagtools/templates/gen_hairpin_winding.mako

@@ -2,11 +2,11 @@
 
 slot_div_angle = 360/m.tot_num_slot
 
-if m.xcoil_1 ~= nil and m.ycoil_1 ~= nil then 
+if m.xcoil_1 ~= nil and m.ycoil_1 ~= nil then
   rcoil, phi_coil = c2pd(m.xcoil_1, m.ycoil_1)
 else
   rcoil, phi_coil = da1/2 + m.slot_height/2, slot_div_angle/2
-end 
+end
 
 -- delete existing mesh in the slot
 for i = 1, m.num_sl_gen do
@@ -173,11 +173,11 @@ for i = 1, #winding do
     slot_nr = winding[i][2]
     layer = winding[i][3]
     direction = winding[i][4]
-    if direction < 0 then 
+    if direction < 0 then
       dir = 'wo'
     else
       dir = 'wi'
-    end 
+    end
     if i == 1 then
           if slot_nr <= m.num_sl_gen then
               wkey = def_new_wdg(wire_xy[slot_nr][layer].x, wire_xy[slot_nr][layer].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, dir)
@@ -188,7 +188,7 @@ for i = 1, #winding do
               if slot_nr <= m.num_sl_gen then
                   add_to_wdg (wire_xy[slot_nr][layer].x, wire_xy[slot_nr][layer].y, "wsamekey", dir, "wser")
               end
-            
+
           else
               if slot_nr <= m.num_sl_gen then
                   wkey = def_new_wdg(wire_xy[slot_nr][layer].x, wire_xy[slot_nr][layer].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, dir)
@@ -197,4 +197,6 @@ for i = 1, #winding do
           end
    end
 end
-m.num_par_wdgs = ${model.get('num_par_wdgs', 1)}
+m.num_par_wdgs = ${model.get('num_par_wdgs', 1)}
+
+pre_models("gen_pocfile")

femagtools/templates/ld_lq_fast.mako

@@ -38,4 +38,4 @@ m.load_ex_cur    =     ${model.get('load_ex_cur',0)}
 run_models("ld_lq_f_cur")
 %else:
 run_models("ld_lq_fast")
-%endif
+%endif

femagtools/templates/mesh-airgap.mako

@@ -19,6 +19,7 @@ if not airgap_created then
     end
     x1, y1 = pr2c(r1, alfa)
     n = math.floor(m.fc_radius*alfa/agndst + 1.5)
+    n = n/10 -- Otherwise stacking mesh error TODO find a better formula
     nc_circle_m(r1, 0, x1, y1, 0.0, 0.0, n)
     if(m.npols_gen == m.num_poles) then
        nc_circle_m(x1, y1, r1, 0, 0.0, 0.0, n)

femagtools/templates/noloadflux-rot.mako

@@ -106,9 +106,13 @@ rotate({
 })
 
 file_psi = io.open("psi-rot-mag.dat","w")
+value={}
+temp={}
 for n=1,nrot+1 do
 
   pos, bag = calc_field(phi, curvec, file_psi)
+  value[n]=#pos
+  temp[n]=pos
   bags[n] = bag
   phi = n*dphi
   rotate({angle=phi, mode="absolute"})
@@ -116,16 +120,40 @@ end
 rotate({mode = "reset"})  -- restore the initial state (discard any changes)
 file_psi:close()
 
+-- add otherwise nil value in bags[n][i][k]
+for i=1, #value-1 do
+  if value[i]<value[i+1] then
+    num_pos=value[i]
+  end
+end 
+-- end
+
+--for i=1, #curvec do
+--  bagfile = string.format("noloadbag-%d.dat", i)
+--  file_bag = io.open(bagfile,"w")
+--  for k = 1, num_pos do --#pos do -- add otherwise nil value in bags[n][i][k]
+--     file_bag:write(string.format("%g ", pos[k]))
+--     for n=1, nrot+1 do
+--      file_bag:write(string.format("%g ",
+--         bags[n][i][k]))  -- Br, rotpos, cur, pos
+--     end
+--     file_bag:write("\n")
+--  end
+--  file_bag:close()
+--end
+
+-- add otherwise nil value in bags[n][i][k]
 for i=1, #curvec do
   bagfile = string.format("noloadbag-%d.dat", i)
   file_bag = io.open(bagfile,"w")
-  for k = 1, #pos do
-     file_bag:write(string.format("%g ", pos[k]))
-     for n=1, nrot+1 do
+  for n=1, nrot+1 do
+     for k = 1, value[n] do --#pos do 
+      pos=temp[n]
+      file_bag:write(string.format("%g ", pos[k]))
       file_bag:write(string.format("%g ",
          bags[n][i][k]))  -- Br, rotpos, cur, pos
      end
      file_bag:write("\n")
   end
   file_bag:close()
-end
+end

femagtools/templates/rotor_winding_ks2.mako

@@ -0,0 +1,44 @@
+-- Winding (ROTOR_KS2)
+
+Q1 = m.tot_num_sl
+Q2 = ${model['num_slots']}
+m.tot_num_sl      = Q2
+% if model.get('num_slots_gen', 0):
+m.num_sl_gen  =   ${model['num_slots_gen']}
+% else:
+m.num_sl_gen  =   Q2 * m.npols_gen/m.num_poles
+% endif
+
+
+
+m.zeroangl        = ${model.get('zeroangl',0)}
+
+m.mcvkey_yoke = mcvkey_yoke
+
+
+dphi=1e-2
+
+num_wires=1
+dir = {'wi', 'wo'}
+
+-- set subregions 'Bar'
+r=da2/2 - m.slot_height/2
+phi=180/Q2+m.zeroangl
+xcoil, ycoil = pd2c(r,phi-dphi)
+--delete_sreg(xcoil, ycoil)
+--def_new_wdg(xcoil, ycoil, yellow, "Exc", num_wires, 10.0, dir[1])
+def_currdens_se(xcoil, ycoil, 5)
+
+for i=2, m.num_sl_gen do
+  phi=(2*i-1)*180/Q2 + m.zeroangl
+  xcoil, ycoil = pd2c(r,phi)
+  --delete_sreg(xcoil, ycoil)
+  pole_per_encoche = Q2 / m.num_poles
+  pole_num = i // pole_per_encoche
+
+  if pole_num % 2 == 0
+	then def_currdens_se(xcoil, ycoil, 5) --add_to_wdg(xcoil, ycoil, wsamekey, dir[1], 'wser')
+  else
+     def_currdens_se(xcoil, ycoil, -5) --add_to_wdg(xcoil, ycoil, wsamekey, dir[2], 'wser')
+end
+end

femagtools/templates/rotor_winding_ks2_ecSimulation.mako

@@ -0,0 +1,44 @@
+-- Winding (ROTOR_KS2)
+
+Q1 = m.tot_num_sl
+Q2 = ${model['num_slots']}
+m.tot_num_sl      = Q2
+% if model.get('num_slots_gen', 0):
+m.num_sl_gen  =   ${model['num_slots_gen']}
+% else:
+m.num_sl_gen  =   Q2 * m.npols_gen/m.num_poles
+% endif
+
+
+
+m.zeroangl        = ${model.get('zeroangl',0)}
+
+m.mcvkey_yoke = mcvkey_yoke
+
+
+dphi=1e-2
+
+num_wires=1
+dir = {'wi', 'wo'}
+
+-- set subregions 'Bar'
+r=da2/2 - m.slot_height/2
+phi=180/Q2+m.zeroangl
+xcoil, ycoil = pd2c(r,phi-dphi)
+--delete_sreg(xcoil, ycoil)
+--def_new_wdg(xcoil, ycoil, yellow, "Exc", num_wires, 10.0, dir[1])
+def_currdens_se(xcoil, ycoil, 5)
+
+--for i=2, m.num_sl_gen do
+--  phi=(2*i-1)*180/Q2 + m.zeroangl
+--  xcoil, ycoil = pd2c(r,phi)
+--  --delete_sreg(xcoil, ycoil)
+--  pole_per_encoche = Q2 / m.num_poles
+--  pole_num = i // pole_per_encoche
+
+--  if pole_num % 2 == 0
+--	then def_currdens_se(xcoil, ycoil, 5) --add_to_wdg(xcoil, ycoil, wsamekey, dir[1], 'wser')
+--  else
+--     def_currdens_se(xcoil, ycoil, -5) --add_to_wdg(xcoil, ycoil, wsamekey, dir[2], 'wser')
+--end
+--end

femagtools/templates/statorRing.mako

@@ -52,7 +52,7 @@ nc_circle_m(xw2, yw2, x8, y8, 0,0,0)
 nc_circle_m(x4, y4, xw3, yw3, 0,0,0)
 nc_circle_m(xw4, yw4, x7, y7, 0,0,0)
 
-x, y = (x4+x7)/2, (y4+y5)/2
+x, y = (x7+x5)/2, (y4+y6)/2
 create_mesh_se(x, y)
 
 def_new_sreg(x, y, 'StZa', 'skyblue')