ElectricMachines_WindingDiagram_lap_fractionalPitch.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/bingsen-wang/Electric-Machines/blob/main/ElectricMachines_WindingDiagram_lap_fractionalPitch.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jAMKoELNpsK-"
      },
      "source": [
        "<center><h1><b>Electric Machine Winding Diagrams: Fractional-Pitch Lap Winding</h1></b>\n",
        "\n",
        "Dr. Bingsen Wang\n",
        "\n",
        "8/22/2024\n",
        "</center>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hv0YxDrWU4h8"
      },
      "source": [
        "#Python Code\n",
        "The Python code illustrates the lap winding diagram."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "XeGsHYTt8IXU"
      },
      "outputs": [],
      "source": [
        "from os import linesep\n",
        "import numpy as np\n",
        "from numpy import linspace,cos,sin,pi,exp,angle,array,sqrt,arcsin,conj\n",
        "import matplotlib as mpl\n",
        "import matplotlib.pyplot as plt\n",
        "import matplotlib.patches as mp\n",
        "from matplotlib.path import Path\n",
        "from matplotlib.patches import PathPatch,Arc,Circle\n",
        "from matplotlib import animation,transforms,colors\n",
        "plt.rcParams.update({'font.family':\"sans serif\",'animation.html':'jshtml'})\n",
        "\n",
        "def axis_reset(ax): #clear axis for redrawing\n",
        "  xy=ax.axis(); ax.cla(); ax.axis('off'); ax.set(xlim=xy[:2],ylim=xy[-2:])\n",
        "  return\n",
        "def re_im(c):\n",
        "  return list(zip(c.real,c.imag))\n",
        "def r2d(rad):\n",
        "  return rad*180/pi\n",
        "\n",
        "def draw_coil_side(ax,x,y,l,top=True,lw=2,c='k',slotNumber=''):\n",
        "  plt.axes(ax)\n",
        "  if top:\n",
        "    ax.plot([x,x],[y,y+l],c=c,lw=lw)\n",
        "  else:\n",
        "    plt.vlines(x+.01,y,y+l,ls='--',color=c,lw=lw)\n",
        "  ax.text(x,y+l*.5,slotNumber,size=11,ha='center',va='center')\n",
        "  return\n",
        "\n",
        "def draw_coil_end_front(ax,x,y,dx,dy,l,ss,pp,tlb='',ipcon=False,\n",
        "                        pn=0,top=True,first=False,last=False,phase_end=False,\n",
        "                        lw=2,c='k',xmax=10,xmin=-10):\n",
        "  \"\"\"\n",
        "  x,y: meeting point of coil side and coil end front\n",
        "  dx,dy: coil end front from x,y to x+dx,y+dy\n",
        "  l: coil side length\n",
        "  ss: slot spacing in winding diagram\n",
        "  tlb: terminal label\n",
        "  pp: pole pitch\n",
        "  pn: phase number 0,1,2 for a,b,c\n",
        "  ipcon: inter-pole connection\"\"\"\n",
        "  if top:\n",
        "    if x+dx>xmax:\n",
        "      ax.plot([x,xmax],[y,y-dy*(xmax-x)/dx],c=c,lw=lw)\n",
        "      ax.plot([xmin,xmin+x+dx-xmax],[y-dy*(xmax-x)/dx,y-dy],c=c,lw=lw)\n",
        "      x0,y0 = xmin+x+dx-xmax-ss/4,y-dy+dy/dx*ss/4\n",
        "      if first: #start terminal\n",
        "        ax.plot([x0,x0],[y0,y0-.2*l],c=c,lw=lw)\n",
        "        ax.text(x0,y0-.21*l,tlb,size=14,c=c,ha='center',va='top')\n",
        "      else: #inter-coil connection\n",
        "        ax.plot([x0,x0,x0-ss/2,x0-ss/2],[y0,y0-.1,y0-.1,y0],c=c,lw=lw*.5)\n",
        "    else:\n",
        "      ax.plot([x,x+dx],[y,y-dy],c=c,lw=lw)\n",
        "      x0,y0 = x+dx-ss/4,y-dy+dy/dx*ss/4\n",
        "      if first: #start terminal\n",
        "        ax.plot([x0,x0],[y0,y0-.2*l],c=c,lw=lw)\n",
        "        ax.text(x0,y0-.21*l-.01,tlb,size=14,c=c,ha='center',va='top')\n",
        "      else: #inter-coil connection\n",
        "        ax.plot([x0,x0,x0-ss/2,x0-ss/2],[y0,y0-.1,y0-.1,y0],c=c,lw=lw*.5)\n",
        "  else:\n",
        "    if x+.01-dx<xmin:\n",
        "      ax.plot([x+.01,xmin],[y,y-dy*(x-xmin)/dx],'--',c=c,lw=lw)\n",
        "      ax.plot([xmax,xmax+x+.01-dx-xmin],[y-dy*(x-xmin)/dx,y-dy],'--',c=c,lw=lw)\n",
        "      x0,y0 = xmax+x+.01-dx-xmin+ss/4,y-dy+dy/dx*ss/4\n",
        "      if last: #end terminal\n",
        "        ax.plot([x0,x0],[y0,y0-.1*l-.05*pn],c=c,lw=lw)\n",
        "        if ipcon: #inter-pole connection\n",
        "          ax.plot([x0,x0-ss*pp-.01],[y0-.1*l-.05*pn,y0-.1*l-.05*pn],c=c,lw=lw)\n",
        "    else:\n",
        "      ax.plot([x+.01,x-dx],[y,y-dy],'--',c=c,lw=lw)\n",
        "      x0,y0 = x-dx+ss/4,y-dy+dy/dx*ss/4\n",
        "      if last: #end terminal\n",
        "        ax.plot([x0,x0],[y0,y0-.1*l-.05*pn],c=c,lw=lw)\n",
        "        if ipcon: #inter-pole connection\n",
        "          if x0-ss*pp<xmin:\n",
        "            ax.plot([x0,x0+ss*pp],[y0-.1*l-.05*pn,y0-.1*l-.05*pn],c=c,lw=lw)\n",
        "          else:\n",
        "            ax.plot([x0,x0-ss*pp],[y0-.1*l-.05*pn,y0-.1*l-.05*pn],c=c,lw=lw)\n",
        "  return\n",
        "\n",
        "def draw_coil_end_back(ax,x,y,dx,dy,l,top=True,lw=2,c='k',xmax=10,xmin=-10):\n",
        "  if top:\n",
        "    if x+dx>xmax:\n",
        "      ax.plot([x,xmax],[y+l,y+l+dy*(xmax-x)/dx],c=c,lw=lw)\n",
        "      ax.plot([xmin,xmin+x+dx-xmax],[y+l+dy*(xmax-x)/dx,y+l+dy],c=c,lw=lw)\n",
        "    else:\n",
        "      ax.plot([x,x+dx],[y+l,y+l+dy],c=c,lw=lw)\n",
        "  else:\n",
        "    if x+.01-dx<xmin:\n",
        "      ax.plot([x+.01,xmin],[y+l,y+l+dy*(x-xmin)/dx],'--',c=c,lw=lw)\n",
        "      ax.plot([xmax,xmax+x+.01-dx-xmin],[y+l+dy*(x-xmin)/dx,y+l+dy],'--',c=c,lw=lw)\n",
        "    else:\n",
        "      ax.plot([x+.01,x-dx],[y+l,y+l+dy],'--',c=c,lw=lw)\n",
        "  return\n",
        "\n",
        "def draw_stator(ax,ro,ri,ns,fc='w',ec='k',lw=1,alpha=1,theta=0):\n",
        "  \"\"\"ro: outer radius;  ri: inner radius; ns: number of slots\"\"\"\n",
        "  ax.add_patch(mp.Circle((0,0),ro,lw=lw,fc=fc,ec=ec,alpha=alpha))\n",
        "  v,c=[],[]\n",
        "  tts = 2*pi/ns #tooth spacing in rad\n",
        "  tsi,ds = tts*.45, (ro-ri)*.5 #slot span at ri in rad, slot depth\n",
        "  tsp,tso = tsi*.6,tts-2*arcsin(ri*sin(.5*(tts-tsi))/(ri+ds)) #slot opening, slot bottom angle span\n",
        "  tt = 2*ri*sin(.5*(tts-tsi)) #tooth thickness\n",
        "  xy1 = exp(-1j*tsp*.5)*ri+.2*tt\n",
        "  xy2 = exp(-1j*tsi*.5)*ri+.3*tt*exp(-1j*tts/2)\n",
        "  xy3 = exp(-1j*tso/2)*(ri+ds)\n",
        "  xy = [xy1,xy2,xy3,xy3+.2*(xy3-xy2)] #splot profile points\n",
        "  pts0 = np.array(xy+list(conj(xy[::-1]))) #[xy,xy's reverse conjugate]\n",
        "  for k in range(ns):\n",
        "    pts = pts0*exp(1j*k*tts)\n",
        "    v += re_im(pts)\n",
        "    c += [Path.LINETO]*3+[Path.CURVE4]*3+[Path.LINETO]*3\n",
        "    ac = Path.arc(r2d(tts*k+.5*tsp),r2d(tts*(k+1)-.5*tsp))\n",
        "    v += list(ac.vertices*ri) #inner arc\n",
        "    c += list(ac.codes[1:])\n",
        "    tr = transforms.Affine2D().rotate(tts*k+theta)+ax.transData\n",
        "  tr = transforms.Affine2D().rotate(theta)+ax.transData\n",
        "  p = Path(v+[[0,0]],[Path.MOVETO]+c[1:]+[Path.CLOSEPOLY])\n",
        "  ax.add_patch(PathPatch(p,ec=colors.to_rgba(ec,alpha),fc='w',lw=lw,transform=tr))\n",
        "  return\n",
        "\n",
        "def draw_stator_conductor_side(ax,ro,ri,n,theta_ss,c='k',theta=0,top=True,slotNumber='',first=True):\n",
        "  \"\"\"\n",
        "  n: slot number; theta_ss: slot spacing in rad\n",
        "  first: first set of coils in a phase belt\n",
        "  \"\"\"\n",
        "  ds=(ro-ri)*.5 #slot depth\n",
        "  tr = transforms.Affine2D().rotate(theta+(n-1)*theta_ss)+ax.transData\n",
        "  if top:\n",
        "    ax.add_patch(mp.Circle((ri+ds*.3,0),ds*.08,ec=c,fc='None',transform=tr))\n",
        "    if first:\n",
        "      ax.scatter(ri+ds*.3,0,marker='x',s=80,color=c,lw=2,transform=tr)\n",
        "    else:\n",
        "      ax.scatter(ri+ds*.3,0,marker='o',s=40,color=c,transform=tr)\n",
        "  else:\n",
        "    ax.add_patch(mp.Circle((ri+ds*.8,0),ds*.08,ec=c,fc='None',transform=tr))\n",
        "    if first:\n",
        "      ax.scatter(ri+ds*.8,0,marker='o',s=40,color=c,transform=tr)\n",
        "    else:\n",
        "      ax.scatter(ri+ds*.8,0,marker='x',s=80,color=c,lw=2,transform=tr)\n",
        "  ax.text(ri+ds*1.3,0,slotNumber,size=14,va='center',ha='center',transform=tr)\n",
        "  return\n",
        "\n",
        "def draw_stator_conductor_end(ax,ro,ri,n,theta_ss,csp,ec='k',lw=2,theta=0,top=True):\n",
        "  \"\"\"n: slot number;\n",
        "  theta_ss: slot spacing in rad;\n",
        "  csp: coil span in number of slots\"\"\"\n",
        "  ds=(ro-ri)*.5 #slot depth\n",
        "  rtop = ri+ds*.3\n",
        "  rbot = ri+ds*.8\n",
        "  rtip = ro*.95\n",
        "  npts = 30\n",
        "  tr = transforms.Affine2D().rotate(theta+(n-1)*theta_ss)+ax.transData\n",
        "  if top:\n",
        "    pts = [(rtop+(rtip-rtop)*(k/npts)**.3)*exp(1j*k*csp*.5*theta_ss/npts) for k in range(npts+1)]\n",
        "  else:\n",
        "    pts = [(rbot+(rtip-rbot)*(k/npts)**.3)*exp(-1j*k*csp*.5*theta_ss/npts) for k in range(npts+1)]\n",
        "  v = re_im(array(pts))\n",
        "  c = [Path.MOVETO]+[Path.LINETO]*(npts)\n",
        "  p = Path(v,c)\n",
        "  if top:\n",
        "    ax.add_patch(PathPatch(p,ec=ec,fc='None',lw=lw,transform=tr))\n",
        "  else:\n",
        "    ax.add_patch(PathPatch(p,ec=ec,fc='None',lw=lw*.6,transform=tr))\n",
        "  return\n",
        "\n",
        "#parameters\n",
        "Nfps = 10 #number of frames\n",
        "Ns = 24 #number of slots\n",
        "ph = 3 #number of phases\n",
        "Nph = int(Ns/ph) #number of slots per phase\n",
        "P = 2 #number of poles\n",
        "Npph = int(Ns/(P*ph)) #number of slots per pole per phase\n",
        "pp = int(Ns/P) #pole pitch\n",
        "csp = int(pp-2) #coil span\n",
        "cp = csp/pp #coil pitch\n",
        "lcs = 2.5 #coil side length\n",
        "x0,y0 = 0,-1 #origin for winding diagram\n",
        "\n",
        "rso = 4.2 #stator outer radius\n",
        "rsi = 2.2 #stator inner radius\n",
        "xylim = [[-5,5] for _ in range(2)]\n",
        "xlim1,ylim1 = [-.1,2.1],[-2.5,2.5]\n",
        "ss = xlim1[1]/Ns #slot spacing in winding diagram\n",
        "cs = list(mpl.cm.tab20.colors) + ['w','k'] #color sequence\n",
        "# fig = plt.figure(figsize=(16,9)) #landscape\n",
        "# ar = 9/16 #aspect ratio\n",
        "# ax = fig.add_axes((1-ar*.6,.2,ar*.6,.6),xlim=xylim[0],ylim=xylim[1],fc='none')\n",
        "# ax.axis('off')\n",
        "# ax1 = fig.add_axes((0,0,1-ar*.6,1),xlim=xlim1,ylim=ylim1,fc='none')\n",
        "# ax1.axis('off')\n",
        "# ax2 = fig.add_axes((1-ar*.6,.2,ar*.6,.6),xlim=xylim[0],ylim=xylim[1],fc='none')\n",
        "# ax2.axis('off')\n",
        "fig = plt.figure(figsize=(9,16)) #portrait\n",
        "ar = 16/9 #aspect ratio\n",
        "ax = fig.add_axes((0,1-1/ar,1,1/ar),xlim=xylim[0],ylim=xylim[1],fc='none')\n",
        "ax.axis('off')\n",
        "ax1 = fig.add_axes((0,0,1,1-1/ar),xlim=xlim1,ylim=ylim1,fc='none')\n",
        "ax1.axis('off')\n",
        "ax2 = fig.add_axes((0,1-1/ar,1,1/ar),xlim=xylim[0],ylim=xylim[1],fc='none')\n",
        "ax2.axis('off')\n",
        "\n",
        "\n",
        "# for ii in range(ph): #for testing\n",
        "#   # ii=0\n",
        "#   for jj in range(P):\n",
        "#     # jj=0\n",
        "#     for kk in range(Npph):\n",
        "#       # if jj==0:\n",
        "#       ntop = str((kk+Nph*ii+jj*pp)%Ns+1)\n",
        "#       nbot = str((kk+csp+Nph*ii+jj*pp)%Ns+1)\n",
        "#       # else:\n",
        "#       #   ntop = ''\n",
        "#       #   nbot = ''\n",
        "\n",
        "#       #step 0\n",
        "#       if kk==0:\n",
        "#         terminal = [['A','B','C'],['A\\'','B\\'','C\\'']][jj][ii]\n",
        "#         # print(terminal)\n",
        "#         draw_coil_end_front(ax1,x0+(kk+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,tlb=terminal,\n",
        "#                           c=cs[6-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,first=True)\n",
        "#       else:\n",
        "#         draw_coil_end_front(ax1,x0+(kk+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,\n",
        "#                           c=cs[6-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss)\n",
        "\n",
        "#       #step 1\n",
        "#       draw_stator_conductor_end(ax2,rso,rsi,(kk+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,csp,ec=cs[6-2*ii])\n",
        "\n",
        "#       #step 2\n",
        "#       draw_coil_side(ax1,x0+(kk+Nph*ii+jj*pp)%Ns*ss,y0,lcs,c=cs[6-2*ii],slotNumber=ntop)\n",
        "\n",
        "#       #step 3\n",
        "#       if jj==0:\n",
        "#         draw_stator_conductor_side(ax2,rso,rsi,(kk+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,c=cs[6-2*ii],slotNumber=ntop)\n",
        "#       else:\n",
        "#         draw_stator_conductor_side(ax2,rso,rsi,(kk+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,c=cs[6-2*ii],slotNumber=ntop,first=False)\n",
        "\n",
        "#       #step 4\n",
        "#       draw_coil_end_back(ax1,x0+(kk+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,\n",
        "#                          c=cs[6-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss)\n",
        "\n",
        "#       #step 5\n",
        "#       draw_coil_end_back(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,\n",
        "#                          c=cs[7-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,top=False)\n",
        "\n",
        "#       #step 6\n",
        "#       draw_coil_side(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,lcs,\n",
        "#                      c=cs[7-2*ii],slotNumber=nbot,top=False) #bottom side\n",
        "\n",
        "#       #step 7\n",
        "#       if jj==0:\n",
        "#         draw_stator_conductor_side(ax2,rso,rsi,(kk+csp+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,\n",
        "#                             c=cs[7-2*ii],slotNumber=nbot,top=False)\n",
        "#       else:\n",
        "#         draw_stator_conductor_side(ax2,rso,rsi,(kk+csp+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,\n",
        "#                             c=cs[7-2*ii],slotNumber=nbot,top=False,first=False)\n",
        "\n",
        "#       #step 8\n",
        "#       if kk==Npph-1: #last bottom coil end\n",
        "#         if jj==P-1: #last pole\n",
        "#           draw_coil_end_front(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,ipcon=True,\n",
        "#                           pn=ii,c=cs[7-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,top=False,last=True)\n",
        "#         else:\n",
        "#           draw_coil_end_front(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,\n",
        "#                           pn=ii,c=cs[7-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,top=False,last=True)\n",
        "#       else:\n",
        "#         draw_coil_end_front(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,\n",
        "#                           c=cs[7-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,top=False)\n",
        "\n",
        "#       #step 9\n",
        "#       draw_stator_conductor_end(ax2,rso,rsi,(kk+csp+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,csp,ec=cs[7-2*ii],top=False)\n",
        "\n",
        "\n",
        "# animation function. This is called sequentially\n",
        "def animate(i):\n",
        "  # i=10\n",
        "  if i%20==0: print(i)\n",
        "  ii = int(int(i/10)/Nph)\n",
        "  jj = int(int(i/10)/Npph)%2\n",
        "  kk = int(i/10)%(Npph)\n",
        "  mm = i%10\n",
        "  # if jj==0:\n",
        "  ntop = str((kk+Nph*ii+jj*pp)%Ns+1)\n",
        "  nbot = str((kk+csp+Nph*ii+jj*pp)%Ns+1)\n",
        "  # else:\n",
        "  #   ntop = ''\n",
        "  #   nbot = ''\n",
        "  match mm:\n",
        "    case 0:\n",
        "      if kk==0:\n",
        "        terminal = [['A','B','C'],['A\\'','B\\'','C\\'']][jj][ii]\n",
        "        draw_coil_end_front(ax1,x0+(kk+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,tlb=terminal,\n",
        "                          c=cs[6-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,first=True)\n",
        "      else:\n",
        "        draw_coil_end_front(ax1,x0+(kk+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,\n",
        "                          c=cs[6-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss)\n",
        "\n",
        "    case 1:\n",
        "      draw_stator_conductor_end(ax2,rso,rsi,(kk+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,csp,ec=cs[6-2*ii])\n",
        "\n",
        "    case 2:\n",
        "      draw_coil_side(ax1,x0+(kk+Nph*ii+jj*pp)%Ns*ss,y0,lcs,c=cs[6-2*ii],slotNumber=ntop)\n",
        "\n",
        "    case 3:\n",
        "      if jj==0:\n",
        "        draw_stator_conductor_side(ax2,rso,rsi,(kk+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,c=cs[6-2*ii],slotNumber=ntop)\n",
        "      else:\n",
        "        draw_stator_conductor_side(ax2,rso,rsi,(kk+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,c=cs[6-2*ii],slotNumber=ntop,first=False)\n",
        "\n",
        "    case 4:\n",
        "      draw_coil_end_back(ax1,x0+(kk+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,\n",
        "                         c=cs[6-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss)\n",
        "\n",
        "    case 5:\n",
        "      draw_coil_end_back(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,\n",
        "                      c=cs[7-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,top=False)\n",
        "\n",
        "    case 6: #bottom-layer coil side in winding diagram\n",
        "      draw_coil_side(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,lcs,\n",
        "                  c=cs[7-2*ii],slotNumber=nbot,top=False)\n",
        "\n",
        "    case 7: #bottom-layer stator conductor side in stator drawing\n",
        "      if jj==0:\n",
        "        draw_stator_conductor_side(ax2,rso,rsi,(kk+csp+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,\n",
        "                            c=cs[7-2*ii],slotNumber=nbot,top=False)\n",
        "      else:\n",
        "        draw_stator_conductor_side(ax2,rso,rsi,(kk+csp+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,\n",
        "                            c=cs[7-2*ii],slotNumber=nbot,top=False,first=False)\n",
        "\n",
        "    case 8: #front coil end from the bottom layer of coil side in widing diagram\n",
        "      if kk==Npph-1: #last bottom coil end\n",
        "        if jj==P-1: #last pole\n",
        "          draw_coil_end_front(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,ipcon=True,\n",
        "                          pn=ii,c=cs[7-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,top=False,last=True)\n",
        "        else:\n",
        "          draw_coil_end_front(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,\n",
        "                          pn=ii,c=cs[7-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,top=False,last=True)\n",
        "      else:\n",
        "        draw_coil_end_front(ax1,x0+(kk+csp+Nph*ii+jj*pp)%Ns*ss,y0,csp*ss/2,.2*lcs,lcs,ss,pp,\n",
        "                          c=cs[7-2*ii],xmax=(Ns-.5)*ss,xmin=-.5*ss,top=False)\n",
        "\n",
        "    case 9: #front coil end from the bottom layer of coil side in stator drawing\n",
        "      draw_stator_conductor_end(ax2,rso,rsi,(kk+csp+Nph*ii+jj*pp)%Ns+1,2*pi/Ns,csp,ec=cs[7-2*ii],top=False)\n",
        "  return\n",
        "\n",
        "draw_stator(ax,rso,rsi,Ns,fc=cs[15],alpha=.8,lw=1)\n",
        "anim = animation.FuncAnimation(fig, animate, interval=1000/4, frames=Ns*10)\n",
        "# anim\n",
        "anim.save(\"ElectricMachine_windingDiagram_fractionalPitch_24slots.mp4\", writer=animation.FFMpegWriter(fps=8), dpi = 200)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}