femagtools 1.7.5__py3-none-any.whl → 1.7.7__py3-none-any.whl

femagtools/machine/utils.py

@@ -14,7 +14,7 @@ logger = logging.getLogger(__name__)
 
 def K(d):
     """space phasor transformation matrix
-    (Inverse Park Transformation) T-1 * dq
+    (Inverse Park Transformation) T-1 * dq --> abc
     arguments:
       d: rotation angle
 
@@ -28,7 +28,7 @@ def K(d):
 
 def T(d):
     """space phasor transformation matrix
-    (Park Transformation) T * abc
+    (Park Transformation) T * abc --> dq
     arguments:
       d: rotation angle
 
@@ -390,21 +390,12 @@ def dqparident(workdir, engine, temp, machine,
         fcu = 0.42
 
     try: # calc basic dimensions if not fsl or dxf model
+        from ..model import MachineModel
         wdg = create_wdg(machine)
         Q1 = wdg.Q
-        slotmodel = [k for k in machine['stator'] if isinstance(
-            machine['stator'][k], dict)][-1]
-        if slotmodel == 'stator1':
-            hs = machine['stator']['stator1']['slot_rf1'] - \
-                machine['stator']['stator1']['tip_rh1']
-        else:
-            da1 = machine['bore_diam']
-            dy1 = machine['outer_diam']
-            hs = machine['stator'][slotmodel].get(
-                'slot_height', 0.6*(dy1-da1)/2)
-
+        model = MachineModel(machine)
         Jmax = 30e6  # max current density in A/m2
-        Acu = fcu*np.pi*(da1+hs)*hs/Q1/2  # approx. copper area of one slot
+        Acu = fcu*model.slot_area()  # approx. copper area of one slot
         i1_max = round(g*Acu/wdg.l/N*Jmax/10)*10
     except KeyError:
         if kwargs.get('i1_max', 0) == 0:

femagtools/model.py

@@ -15,6 +15,12 @@ MODELNAME_CHARS = string.printable[:63] + "-_äöüéè"
 # maximum name length
 MAX_MODEL_NAME_LEN = 255
 
+default_th_properties = {
+    "spmaweight": 8.96,
+    "tempcoef": 3.9e-3,
+    "thcond": 30,
+    "thcap": 480
+}
 
 def movesteps(nodes):
     """returns list of move steps
@@ -191,6 +197,28 @@ class MachineModel(Model):
         except (KeyError, AttributeError):
             pass
 
+    def slot_height(self):
+        if 'statorRotor3' in self.stator:
+            return self.stator['statorRotor3']['slot_height']
+        if 'stator1' in self.stator:
+            return self.stator['stator1']['slot_rf1'] - self.stator['stator1']['tip_rh1']
+        if 'stator4' in self.stator:
+            return self.stator['stator4']['slot_height']
+        da1 = self.bore_diam
+        if self.external_rotor:
+            yh = da1-self.inner_diam
+        else:
+            yh = da1+self.outer_diam
+        return 0.6*yh/2
+
+    def slot_area(self):
+        if 'slot_area' in self.stator:
+            return self.stator['slot_area']
+        da1 = self.bore_diam
+        Q1 = self.stator['num_slots']
+        hs = self.slot_height()
+        return np.pi*hs*(da1+hs)/Q1/2
+
     def set_num_slots_gen(self):
         if 'num_slots_gen' not in self.stator:
             try:
@@ -392,6 +420,8 @@ class MachineModel(Model):
         for k in self.rotor:
             # anything that is a dict must represent the type
             if isinstance(self.rotor[k], dict):
+                if k == 'rot_hsm':
+                    return 'EESM'
                 return k
         raise AttributeError("Missing rotor model in {}".format(self.magnet))
 
@@ -429,11 +459,11 @@ class MachineModel(Model):
     def props(self):
         """returns dict of this model"""
         keys = ('name', 'poles', 'outer_diam', 'airgap',
-                'bore_diam', 'external_rotor', 'agndst')
+                'bore_diam', 'inner_diam', 'external_rotor', 'agndst')
         model = {k: getattr(self, k) for k in keys if hasattr(self, k)}
         if hasattr(self, 'stator'):
             model['stator'] = {k: self.stator[k]
-                               for k in ('num_slots', 'num_slots_gen')
+                               for k in ('num_slots', 'num_slots_gen', 'slot_area')
                                if k in self.stator}
         return model
 

femagtools/moo/algorithm.py

@@ -71,6 +71,9 @@ class Nsga2:
                                           rnd*alpha))**(1.0/(self.eta_c+1.0))
 
                         c1 = 0.5*((y1+y2)-betaq*(y2-y1))
+                        if isinstance(c1, complex):
+                            logger.warning(f"c1 {c1} is complex")
+                            c1 = abs(c1)
 
                         beta = 1.0 + (2.0*(yu-y2)/(y2-y1))
                         alpha = 2.0 - beta**(-(self.eta_c+1.0))
@@ -81,6 +84,9 @@ class Nsga2:
                                           rnd*alpha))**(1.0/(self.eta_c+1.0))
 
                         c2 = 0.5*((y1+y2)+betaq*(y2-y1))
+                        if isinstance(c2, complex):
+                            logger.warning(f"c2 {c2} is complex")
+                            c2 = abs(c2)
 
                         if c1<yl : c1=yl
                         if c2<yl : c2=yl

femagtools/nc.py

@@ -191,6 +191,8 @@ class Reader(object):
             self.speed = float(grp.variables['speed'].getValue().data)
             self.FC_RADIUS = float(grp.variables['fc_radius'].getValue().data)
             self.pole_pairs = int(grp.variables['pole_pairs'].getValue().data)
+            self.layers = int(grp.variables['num_layers'].getValue().data)
+            self.coil_span = int(grp.variables['coil_span'].getValue().data)
             self.delta_node_angle = float(  # rad
                 grp.variables['delta_node_angle'].getValue().data)
             self.poles_sim = int(grp.variables['poles_sim'].getValue().data)

femagtools/opt.py

@@ -77,7 +77,8 @@ class Optimizer(object):
             set_magnet_properties(self.model, self.fea, self.femag.magnets)
             task.add_file('femag.fsl',
                           self.builder.create(self.model, self.fea,
-                                              self.femag.magnets))
+                                              self.femag.magnets,
+                                              self.femag.condMat))
             if 'poc' in self.fea:
                 task.add_file(self.fea['pocfilename'],
                               self.fea['poc'].content())

femagtools/plot/bch.py

@@ -508,19 +508,33 @@ def transientsc(bch, title=''):
     row = 1
     plt.subplot(rows, cols, row)
     ax = plt.gca()
-    ax.set_title('Currents / A')
     ax.grid(True)
-    for i in ('ia', 'ib', 'ic'):
-        ax.plot(bch.scData['time'], bch.scData[i], label=i)
+    istat = np.array([bch.scData[i]
+                      for i in ('ia', 'ib', 'ic')])
+    if np.max(istat) > 4000:
+        istat *= 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)
     ax.set_xlabel('Time / s')
     ax.legend()
 
     row = 2
     plt.subplot(rows, cols, row)
     ax = plt.gca()
-    ax.set_title('Torque / Nm')
+    scale = 1
+    torque = np.array(bch.scData['torque'])
+    if np.max(torque) > 4000:
+        torque *= 1e-3
+        ax.set_title('Torque / kNm')
+    else:
+        ax.set_title('Torque / Nm')
+
     ax.grid(True)
-    ax.plot(bch.scData['time'], bch.scData['torque'])
+    ax.plot(bch.scData['time'], torque)
     ax.set_xlabel('Time / s')
 
     fig.tight_layout(h_pad=2)

femagtools/plot/char.py

@@ -326,15 +326,15 @@ def _plot_contour(speed, torque, z, ax, title='', levels=[],
     contf = ax.tricontourf(x, y, z,
                            levels=levels, cmap=cmap)
 
+    #ax.plot(x, y, "k.", ms=3)
+    if clabel:
+        ax.clabel(cont, inline=True, colors='k', fontsize=8, inline_spacing=0)
+
     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)
 

femagtools/plot/nc.py

@@ -30,10 +30,27 @@ def spel(isa, superelements=[], with_axis=False, ax=0):
         spels = isa.superelements
     for se in spels:
         ax.add_patch(Polygon([n.xy
-                              for nc in se.nodechains
-                              for n in nc.nodes],
-                             color=isa.color[se.color], lw=0))
-
+                            for nc in se.nodechains
+                            for n in nc.nodes],
+                            color=isa.color[se.color], lw=0))
+        try:
+            # draw wire direction
+            if se.subregion: 
+                if se.subregion.curdir != 0: 
+                        wkey = se.subregion.winding.key
+                        if se.subregion.curdir < 0: 
+                            label = str(se.subregion.curdir*wkey)
+                        else: 
+                            label = '+'+str(se.subregion.curdir*wkey)
+
+                        xy = np.array([n.xy
+                            for nc in se.nodechains
+                            for n in nc.nodes])
+                        cx, cy = np.mean(np.unique(xy[:, 0])), np.mean(np.unique(xy[:, -1]))
+                        ax.text(cx, cy, label, rotation=np.arctan2(cy, cx)/np.pi*180-90, 
+                                horizontalalignment='center', verticalalignment='center')
+        except:
+            pass
     ax.autoscale(enable=True)
     if not with_axis:
         ax.axis('off')

femagtools/plot/wdg.py

@@ -48,19 +48,28 @@ def mmf_fft(f, title='', mmfmin=1e-2, ax=0):
         pass
 
 
-def zoneplan(wdg, ax=0):
+def zoneplan(wdg, write_title=True, max_slots=0, ax=0):
     """plot zone plan of winding wdg"""
     from matplotlib.patches import Rectangle
     upper, lower = wdg.zoneplan()
     Qb = len([n for l in upper for n in l])
+    if max_slots:
+        Qb = max_slots
     from femagtools.windings import coil_color
-    rh = 0.5
+    h = 0.5
+    w = 1
+    dx = -1.5, -1.5
+    dt = 0.5, 0.5
+    yl = 0, 0.
+    ymax = h
     if lower:
-        yl = rh
-        ymax = 2*rh + 0.2
-    else:
-        yl = 0
-        ymax = rh + 0.2
+        if wdg.q < 1:
+            dx = -1, -1.5
+            dt = 0.2, 0.2
+            w = 0.5
+        else:
+            yl = h, 0
+            ymax = 2*h
     if ax == 0:
         ax = plt.gca()
     ax.axis('off')
@@ -70,28 +79,31 @@ def zoneplan(wdg, ax=0):
 
     for i, p in enumerate(upper):
         for x in p:
-            ax.add_patch(Rectangle((abs(x)-1.5, yl), 1, rh,
-                                   facecolor=coil_color[i],
-                                   edgecolor='white', fill=True))
-            s = f'+{i+1}' if x > 0 else f'-{i+1}'
-            ax.text(abs(x)-1, yl+rh/2, s, color='black',
-                    ha="center", va="center")
+            if abs(x) < Qb+1:
+                ax.add_patch(Rectangle((abs(x)+dx[0], yl[0]), w, h,
+                                       facecolor=coil_color[i],
+                                       edgecolor='white', fill=True))
+                s = f'+{i+1}' if x > 0 else f'-{i+1}'
+                ax.text(abs(x)+dx[0]+dt[0], yl[0]+h/2, s, color='black',
+                        ha="center", va="center")
     for i, p in enumerate(lower):
         for x in p:
-            ax.add_patch(Rectangle((abs(x)-1.5, yl-rh), 1, rh,
-                                   facecolor=coil_color[i],
-                                   edgecolor='white', fill=True))
-            s = f'+{i+1}' if x > 0 else f'-{i+1}'
-            ax.text(abs(x)-1, yl-rh/2, s, color='black',
-                    ha="center", va="center")
-
-    yu = yl+rh
+            if abs(x) < Qb+1:
+                ax.add_patch(Rectangle((abs(x)+dx[1], yl[1]), w, h,
+                                       facecolor=coil_color[i],
+                                       edgecolor='white', fill=True))
+                s = f'+{i+1}' if x > 0 else f'-{i+1}'
+                ax.text(abs(x)+dx[1]+dt[1], yl[1]+h/2, s, color='black',
+                        ha="center", va="center")
+
+    yu = yl[0]+h
     step = 1 if Qb < 25 else 2
-    if lower:
-        yl -= rh
+    yl = min(yl)
     margin = 0.05
-    ax.text(-0.5, yu+margin, f'Q={wdg.Q}, p={wdg.p}, q={round(wdg.q,4)}',
-            ha='left', va='bottom', size=15)
+    if write_title:
+        ax.text(-0.5, yu+margin,
+                f'Q={wdg.Q}, p={wdg.p}, q={round(wdg.q,4)}, yd={wdg.yd}',
+                ha='left', va='bottom', size=15)
     for i in range(0, Qb, step):
         ax.text(i, yl-margin, f'{i+1}', ha="center", va="top")
 
@@ -99,7 +111,7 @@ def zoneplan(wdg, ax=0):
 def winding_factors(wdg, n=8, ax=0):
     """plot winding factors"""
     ax = plt.gca()
-    ax.set_title(f'Winding factors Q={wdg.Q}, p={wdg.p}, q={round(wdg.q,4)}')
+    ax.set_title(f'Winding factors Q={wdg.Q}, p={wdg.p}, q={round(wdg.q,4)}, yd={wdg.yd}')
     ax.grid(True)
     order, kwp, kwd, kw = np.array(
         [(n, k1, k2, k3)

femagtools/templates/gen_hairpin_winding.mako

@@ -0,0 +1,209 @@
+-- hairpin winding template
+
+rcoil, phi_coil = c2pd(m.xcoil_1, m.ycoil_1)
+
+slot_div_angle = 360/m.tot_num_slot
+
+-- delete existing mesh in the slot
+for i = 1, m.num_sl_gen do
+    xc, yc = pd2c(rcoil, phi_coil+(i-1)*slot_div_angle)
+    delete_mesh_se(xc, yc)
+end
+-- wire params
+wire_height = ${model['wire']["wire_height"]*1e3}
+wire_width = ${model['wire']["wire_width"]*1e3}
+wire_corner_r = ${model['wire']["corner_radius"]*1e3}
+wire_gap = ${model['wire']["wire_separation"]*1e3}
+TH1 = ${model['wire']["wire_th1"]*1e3} -- distance to the bore radius
+nwires = ${model['wire']["num_layers"]}
+
+fml = require "fml"
+
+function line_xy(pnt1, pnt2, nnodes)
+   -- create line
+  nc_line(pnt1.x, pnt1.y, pnt2.x, pnt2.y, nnodes)
+end
+
+function circle_xy(pnt1, pnt2, cx, cy, nnodes)
+   -- create circle
+  nc_circle_m(pnt1.x, pnt1.y, pnt2.x, pnt2.y, cx, cy, nnodes)
+end
+
+function draw_rectangle_wire(dx, dy, dphi, wire_height, wire_width, r0, agndst)
+
+    local x = {}
+    local y = {}
+    local x1 = {}
+    local y1 = {}
+    local hl = {}
+    local hi = {}
+    local hj = {}
+    local hk = {}
+    local xcp, ycp
+    local tmpx, tmpy, tmpr, tmpp
+
+    h1 = fml.Point:Create(dx, 0)
+    h2 = fml.Point:Create(dx, -wire_width/2+dy)
+    he = fml.Point:Create(dx+wire_height, 0)
+
+    hl[1] = fml.Line:Create(h1, 90)
+    hl[2] = fml.Line:Parallel(hl[1], wire_height)
+    hl[3] = fml.Line:Create(h2, 0)
+    hl[4] = fml.Line:Parallel(hl[3], -wire_width)
+
+    hi[1] = fml.Point:Intersection(hl[1], hl[3])
+    hi[2] = fml.Point:Intersection(hl[1], hl[4])
+    hi[3] = fml.Point:Intersection(hl[2], hl[4])
+    hi[4] = fml.Point:Intersection(hl[2], hl[3])
+    -- with corner
+    if r0 > 0 then
+       s1 = {1, 1, 2, 2}
+       s2 = {3, 4, 4, 3}
+       s3 = {1, 4, 3, 2}
+       ctr = 1
+
+       for i =1, 4 do
+          hj[ctr], hj[ctr+1], hj[ctr+2] = fml.Point:Rounding(hl[s1[i]], hl[s2[i]], r0, s3[i])
+          ctr = ctr + 3
+       end
+
+       for j = 1, #hj do
+          tmpr, tmpp = c2pd(hj[j].x, hj[j].y)
+          tmpx, tmpy = pd2c(tmpr, tmpp+dphi)
+          hk[j] = fml.Point:Create(tmpx, tmpy)
+       end
+
+       dst = agndst/2
+       ah1 = fml.Point:Create((hk[12].x+hk[8].x)/2 , (hk[12].y+hk[8].y)/2)
+       ah2 = fml.Point:Create((hk[6].x+hk[2].x)/2 , (hk[6].y+hk[2].y)/2)
+
+       line_xy(hk[12], ah1, 0)
+       line_xy(ah1, hk[8], 0)
+       line_xy(hk[9], hk[5], 0)
+       line_xy( hk[6], ah2, 0)
+
+       line_xy(ah2, hk[2], 0)
+       line_xy(hk[3], hk[11], 0)
+
+       circle_xy(hk[8], hk[9], hk[7].x, hk[7].y, 6)
+       circle_xy(hk[5], hk[6], hk[4].x, hk[4].y, 6)
+       circle_xy(hk[2], hk[3], hk[1].x, hk[1].y, 6)
+       circle_xy(hk[11], hk[12], hk[10].x, hk[10].y, 6)
+       xcp = (hk[12].x + hk[6].x)/2
+       ycp = (hk[12].y + hk[6].y)/2
+
+    else
+      xcp = 0
+      ycp = 0
+
+      for i = 1, 4 do
+          x[i], y[i] = hi[i].x, hi[i].y
+          tmpr, tmpp = c2pd(x[i], y[i])
+          tmpx, tmpy = pd2c(tmpr, tmpp+dphi)
+          x1[i], y1[i] = tmpx, tmpy
+          xcp = xcp + tmpx/4
+          ycp = ycp + tmpy/4
+      end
+
+      nc_line(x1[1], y1[1], x1[2], y1[2], 0)
+      nc_line_cont(x1[3], y1[3], 0)
+      nc_line_cont(x1[4], y1[4], 0)
+      nc_line_cont(x1[1], y1[1], 0)
+
+    end
+
+    return xcp, ycp, ah1, ah2
+end
+
+-- hairpin winding
+wire_xy = {}
+x0, y0 = da1/2+TH1, 0
+auh1 = {}
+auh2 = {}
+
+for j = 1, m.num_sl_gen do
+   wire_xy[j] = {}
+   for k = 1, nwires do
+    wire_xy[j][k] = 0.0
+   end
+end
+
+ndt(agndst)
+for j = 1, m.num_sl_gen do
+  for i = 1, nwires do
+    dx, dy = x0+(wire_gap+wire_height)*(i-1), y0
+    xcp, ycp, ah1, ah2 = draw_rectangle_wire(dx, dy, 360/m.tot_num_slot/2*(2*j-1), wire_height, wire_width, wire_corner_r, agndst)
+    wire_xy[j][nwires - (i-1)] =  fml.Point:Create(xcp, ycp) -- large radius to smaller radius
+    create_mesh_se(xcp, ycp)
+  end
+
+end
+create_mesh()
+
+-- create winding
+
+widfile = io.open("wid.fsl", 'r')
+
+nrows = 1
+winding = {}
+
+for i in widfile:lines() do
+  winding[nrows] = {}
+  ncols = 1
+  for j in string.gmatch(i, "[+-]?%d+") do
+    winding[nrows][ncols] = tonumber(j)
+    ncols = ncols + 1
+  end
+  nrows = nrows + 1
+end
+
+--[[
+
+winding table
+
+1  slot_go pos_in_slot slot_ret pos_in_slot
+
+]]--
+dir = 'wi'
+cols = {"green", "yellow", "cyan"}
+wk = 1
+for i = 1, #winding do
+    idx = winding[i][2]
+    idxp = winding[i][3]
+    idy = winding[i][4]
+    idyp = winding[i][5]
+
+   if i == 1 then
+        if idx <= m.num_sl_gen then
+            wkey = def_new_wdg(wire_xy[idx][idxp].x, wire_xy[idx][idxp].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, dir)
+        end
+
+        if math.abs(idy) <= m.num_sl_gen then
+            add_to_wdg (wire_xy[math.abs(idy)][idyp].x, wire_xy[math.abs(idy)][idyp].y, "wsamekey", "wo", "wser")
+        end
+   else
+        if winding[i][1] == winding[i-1][1] and winding[i][1] == wk then
+            if idx <= m.num_sl_gen then
+                add_to_wdg (wire_xy[idx][idxp].x, wire_xy[idx][idxp].y, "wsamekey", dir, "wser")
+            end
+            if math.abs(idy) <= m.num_sl_gen then
+                add_to_wdg (wire_xy[math.abs(idy)][idyp].x, wire_xy[math.abs(idy)][idyp].y, "wsamekey", "wo", "wser")
+            end
+        else
+            if idx <= m.num_sl_gen then
+                wkey = def_new_wdg(wire_xy[idx][idxp].x, wire_xy[idx][idxp].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, dir)
+                wk = wk + 1
+            end
+            if math.abs(idy) <= m.num_sl_gen then
+                if wk == winding[i][1] then
+                  add_to_wdg (wire_xy[math.abs(idy)][idyp].x, wire_xy[math.abs(idy)][idyp].y, "wsamekey", "wo", "wser")
+                else
+                  wkey = def_new_wdg(wire_xy[math.abs(idy)][idyp].x, wire_xy[math.abs(idy)][idyp].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, "wo")
+                  wk = wk + 1
+                end
+            end
+        end
+   end
+end
+
+m.num_par_wdgs = ${model.get('num_par_wdgs', 1)}

femagtools/templates/gen_winding.mako

@@ -99,20 +99,19 @@ if m.slot_height ~= nil then
   elseif m.middle_line == 2 then
     dr = 1
   end
-  lamCu = 400
-  capCu = 385
-  da = 1.0785
-  dCu = 1.0
-  lam = lamCu*(dCu/(da-dCu)+(da-dCu)/da)
-  cap = capCu*da^2/(dCu^2*math.pi/4)
+
+  density = ${model.windings['spmaweight']*1e3}
+  lam = ${model.windings['thcond']}
+  cap = ${model.windings['thcap']}
+
   for i=1,m.num_sl_gen do
     a = (2*i-1)*math.pi/m.tot_num_sl + m.zeroangl/180*math.pi
     xwl,ywl = pr2c(rw+dr,a+dw)
-    def_mat_therm(xwl,ywl,'yellow',8920,lam,cap,1)
+    def_mat_therm(xwl,ywl,'yellow',density,lam,cap,1)
     if m.middle_line > 0 then
       xwr,ywr = pr2c(rw-dr,a-dw)
-      def_mat_therm(xwr,ywr,'yellow',8920,lam,cap,1)
+      def_mat_therm(xwr,ywr,'yellow',density,lam,cap,1)
     end
   end
 end
-%endif
+%endif

femagtools/templates/magnetIron.mako

@@ -44,16 +44,25 @@ beta = math.pi/m.num_poles
 xrb,yrb = pr2c(m.yoke_rad+0.1, beta)  -- rotor lamination
 thcond = ${model['thcond']}
 thcap = ${model['thcap']}
-def_mat_therm(xrb,yrb,'blue',7700,thcond,thcap,1)
-def_mat_therm(m.yoke_rad/2,0.1,'blue',7700,thcond,thcap,1) -- Shaft
+density = ${model.get('density')*1e3}
+def_mat_therm(xrb,yrb,'blue',density,thcond,thcap,1)
 
+%if model.get('thcond_shaft', 0) and model.get('thcap_shaft', 0):
+if m.shaft_rad < m.yoke_rad then
+   thcond = ${model['thcond_shaft']}
+   thcap = ${model['thcap_shaft']}
+   density = ${model['spmaweight_shaft']*1e3}
+   def_mat_therm(m.yoke_rad/2,0.1,'blue',density,thcond,thcap,1) -- Shaft
+end
+%endif
 rm = m.magn_rad*math.cos(beta)
-thcond = 8
-thcap = 440
+density = ${model['spmaweight_magnet']*1e3}
+thcond = ${model.get('thcond_magnet', 8)}
+thcap = ${model.get('thcap_magnet', 440)}
 for i = 1,m.npols_gen do -- Magnete
   alfa = (2*i-1) * beta
   xmx,ymx = pr2c(rm,alfa)
-  def_mat_therm(xmx,ymx,darkgreen-i%2,7500,thcond,thcap,1)
+  def_mat_therm(xmx,ymx,darkgreen-i%2,density,thcond,thcap,1)
 end
 
 if m.air_triangle > 0 then
@@ -67,4 +76,21 @@ if m.air_triangle > 0 then
     def_mat_therm(xsx,ysx,skyblue,1.12,0.026,1007,1)
   end
 end
-%endif
+
+
+-- add air layer (inside) for heat transfer
+h = 3.8
+beta = 360*m.npols_gen/m.num_poles
+
+
+x0, y0 = pd2c(m.shaft_rad, m.zeroangl)
+x1, y1 = pd2c(m.shaft_rad-h, m.zeroangl)
+x2, y2 = pd2c(m.shaft_rad-h, beta+m.zeroangl)
+x3, y3 = pd2c(m.shaft_rad, beta+m.zeroangl)
+nc_line(x0, y0, x1, y1, 0)
+nc_circle(x1, y1, x2, y2, 0)
+nc_line(x2, y2, x3, y3, 0)
+x0, y0 = pd2c(m.shaft_rad-h/2, beta/2+m.zeroangl)
+create_mesh_se(x0, y0)
+
+%endif

femagtools/templates/mesh-airgap.mako

@@ -14,13 +14,22 @@ if not airgap_created then
     end
 % if hasattr(model, 'bore_diam'):
     r1 = m.fc_radius - ag/6
+    if(m.npols_gen == m.num_poles) then
+      alfa = alfa / 2
+    end
     x1, y1 = pr2c(r1, alfa)
     n = math.floor(m.fc_radius*alfa/agndst + 1.5)
     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)
+    end
 
     r2 = m.fc_radius + ag/6
     x2, y2 = pr2c(r2, alfa)
     nc_circle_m(r2, 0, x2, y2, 0.0, 0.0, n)
+    if(m.npols_gen == m.num_poles) then
+       nc_circle_m(x2, y2, r2, 0, 0.0, 0.0, n)
+    end
 
     if inner_da_start == nil then
       inner_da_start = da2/2

femagtools/templates/rotor_winding.mako

@@ -1,12 +1,16 @@
--- Winding (ROT_HSM only!)
+-- Winding (ROT_HSM or dxf)
 m.num_wires =  ${model['num_wires']}
 
-a = m.rotor_diam/2 - ag - m.pole_height - m.core_height/2
-b = ((m.core_width1 + m.core_width2)/4 + m.pole_width/2)/2
-r = math.sqrt(a^2 + b^2)
-alpha = math.atan2(b, a)
-
 phi = math.pi/m.num_poles
+if m.xcoil_r == nil then -- ROT_HSM
+  a = m.rotor_diam/2 - ag - m.pole_height - m.core_height/2
+  b = ((m.core_width1 + m.core_width2)/4 + m.pole_width/2)/2
+  r = math.sqrt(a^2 + b^2)
+  alpha = math.atan2(b, a)
+else
+  r,beta  = c2pr(m.xcoil_r, m.ycoil_r)
+  alpha = phi - beta
+end
 dir = {'wi', 'wo'}
 xcoil, ycoil = pr2c(r, phi - alpha)
 def_new_wdg(xcoil, ycoil, yellow, "Exc", m.num_wires, 10.0, dir[1])