femagtools 1.8.6__py3-none-any.whl → 1.8.8__py3-none-any.whl

femagtools/shortcircuit.py

@@ -0,0 +1,378 @@
+import pathlib
+import logging
+import json
+import numpy as np
+import scipy.optimize as so
+from scipy.interpolate import make_interp_spline
+import scipy.integrate as ig
+import femagtools.parstudy
+
+logger = logging.getLogger('shortcircuit')
+
+def _parstudy_list(femag, result_func):
+    workdir = femag.workdir
+    magnetMat = femag.magnets
+    magnetizingCurves = femag.magnetizingCurves
+    condMat = femag.condMat
+    templatedirs = femag.templatedirs
+    cmd = femag.cmd
+    return femagtools.parstudy.List(
+        workdir, condMat=condMat, magnets=magnetMat,
+        magnetizingCurves=magnetizingCurves,
+        cmd=cmd, result_func=result_func)
+
+def get_shortCircuit_parameters(bch, nload):
+    """extracts shortciruit parameters from bch"""
+    try:
+        if nload < 0:
+            nload = 0
+        if nload > 2:
+            nload = 2
+        if nload > 0:
+            dqld = bch.dqPar['ld']
+            dqlq = bch.dqPar['lq']
+            dqpsim = bch.dqPar['psim']
+            if len(dqld) <= nload or len(dqlq) <= nload or len(dqpsim) <= nload:
+                ld = dqld[-1]/bch.armatureLength
+                lq = dqlq[-1]/bch.armatureLength
+                psim = dqpsim[-1]/bch.armatureLength
+            else:
+                ld = dqld[nload-1]/bch.armatureLength
+                lq = dqlq[nload-1]/bch.armatureLength
+                psim = dqpsim[nload-1]/bch.armatureLength
+        else:
+            ld = bch.machine['ld']/bch.armatureLength
+            lq = bch.machine['lq']/bch.armatureLength
+            psim = bch.machine['psim']/bch.armatureLength
+        return dict(
+            r1=bch.machine['r1'],
+            ld=ld,
+            lq=lq,
+            Hk=bch.magnet['demag_hx'],
+            Tmag=bch.magnet['Tmag'],
+            psim=psim,
+            num_pol_pair=bch.machine['p'],
+            fc_radius=bch.machine['fc_radius'],
+            lfe=bch.armatureLength/1e3,
+            pocfilename=bch.machine['pocfile'],
+            num_par_wdgs=bch.machine.get('num_par_wdgs', 1),
+            calculationMode='shortcircuit')
+    except (KeyError, AttributeError, IndexError):
+        raise ValueError("missing pm/Rel-Sim results")
+
+
+def find_peaks_and_valleys(t, y):
+    """ return peak and valley of y with maximum amplitude
+    """
+    peaks = (np.diff(np.sign(np.diff(y))) < 0).nonzero()[0] + 1
+    if len(peaks>0):
+        ip = np.argmax(y[peaks])
+        pv = {'ip': y[peaks][ip], 'tp': t[peaks][ip]}
+    else:
+        pv = {'ip': [], 'tp': []}
+    valleys = (np.diff(np.sign(np.diff(y))) > 0).nonzero()[0] + 1
+    if len(valleys>0):
+        iv = np.argmin(y[valleys])
+        pv.update({'iv': y[valleys][iv], 'tv': t[valleys][iv]})
+    else:
+        pv.update({'iv': [], 'tv': []})
+    pv.update({'peaks': y[peaks], 'valleys': y[valleys],
+               'tpeaks': t[peaks], 'tvalleys': t[valleys]})
+    return pv
+
+def shortcircuit(femag, machine, bch, simulation, engine=0):
+    scdata = {}
+    calcmode = simulation.get('calculationMode', '')
+    simulation.update(
+        get_shortCircuit_parameters(bch,
+                                    simulation.get('initial', 2)))
+    if 'speed' not in simulation:
+        simulation['speed'] = bch.dqPar['speed']
+    if simulation.get('sc_type', 3) == 3:
+        logger.info("3phase short circuit simulation")
+        builder = femagtools.fsl.Builder(femag.templatedirs)
+        fslcmds = (builder.open_model(femag.model) +
+                   builder.create_shortcircuit(simulation))
+        fslfile = 'shortcircuit.fsl'
+        (pathlib.Path(femag.workdir)/fslfile).write_text(
+            '\n'.join(fslcmds),
+            encoding='latin1', errors='ignore')
+        femag.run(fslfile)  # options?
+        bchfile = femag.get_bch_file(femag.modelname)
+        if bchfile:
+            bchsc = femagtools.bch.Reader()
+            logger.info("Read BCH %s", bchfile)
+            bchsc.read(pathlib.Path(bchfile).read_text(
+                encoding='latin1', errors='ignore'))
+            bchsc.scData['demag'] = bchsc.demag
+            if simulation.get('sim_demagn', 0):
+                d = {'displ': [d['displ']
+                               for d in bchsc.demag if 'displ' in d],
+                     'H_max': [d['H_max']
+                               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]}
+                simulation['i1max'] = bchsc.scData['iks']
+                bchsc.scData['demag'] = demag(
+                    femag, machine, simulation, engine)
+                bchsc.scData['demag'].update(d)
+            scdata = bchsc.scData
+            #for w in bch.flux:
+            #    try:
+            #        bch.flux[w] += bchsc.flux[w]
+            #        bch.flux_fft[w] += bchsc.flux_fft[w]
+            #    except (KeyError, IndexError):
+            #        logging.debug(
+            #            "No additional flux data in sc simulation")
+            #        break
+
+    if simulation.get('sc_type', 3) == 2:
+        if 'i1max' not in simulation:
+            # just a wild guess
+            simulation['i1max'] = 4.5*bch.machine['i1']
+        logger.info("2phase short circuit simulation i1max = %.0f",
+                    simulation['i1max'])
+        scdata = shortcircuit_2phase(femag, machine, simulation, engine)
+
+    else:
+        logger.warning("Empty shortcircuit results for type %d",
+                       simulation.get('sc_type', 'unknown'))
+    # must reset calcmode
+    if calcmode:
+        simulation['calculationMode'] = calcmode
+    else:
+        del simulation['calculationMode']
+    return scdata
+
+def sc_result_func(task):
+    basedir = pathlib.Path(task.directory)
+    psitorq = np.loadtxt(basedir/'psi-torq-rot.dat')
+    pos = np.unique(psitorq[:, 0])
+    ncurs = psitorq[:, 0].shape[0]//pos.shape[0]
+    ire = psitorq[:ncurs, 1:4]
+    psire = np.reshape(psitorq[:, 4:7], (-1, ncurs, 3))
+    torq = np.reshape(psitorq[:, 7], (-1, ncurs))
+    return {'pos': pos.tolist(), 'ire': ire.tolist(),
+            'psire': psire.tolist(), 'torq': torq.tolist()}
+
+
+def shortcircuit_2phase(femag, machine, simulation, engine=0):
+    i1max = simulation['i1max']
+    num_cur_steps = 4
+    i1 = np.linspace(0, i1max, num_cur_steps)
+    i1vec = np.concat((-i1[::-1], i1[1:]))
+    num_par_wdgs = machine['winding'].get('num_par_wdgs', 1)
+    flux_sim = {
+        'calculationMode': 'psi-torq-rot',
+        'i1max': i1max,
+        'curvec': [],
+        'num_par_wdgs': num_par_wdgs}
+
+    if engine:
+        parstudy = _parstudy_list(femag, sc_result_func)
+        parvardef = {
+            "decision_vars": [
+                {"values": i1vec, "name": "curvec"}]
+        }
+        results = parstudy(parvardef, machine, flux_sim, engine)
+
+        ire = np.array([r['ire'][0] for r in results['f']])
+        pos = np.array(results['f'][0]['pos'])
+        phi = pos*np.pi/180
+        torq = np.hstack([r['torq'] for r in results['f']])
+        psire = np.hstack([r['psire'] for r in results['f']])
+    else:
+        simulation.update(flux_sim)
+        simulation['curvec'] = i1vec.tolist()
+        results = femag(machine, simulation)
+        class Task:
+            def __init__(self, workdir):
+                self.directory = workdir
+        results = sc_result_func(Task(femag.workdir))
+        ire = np.array(results['ire'])
+        pos = np.array(results['pos'])
+        torq = np.array(results['torq'])
+        psire = np.array(results['psire'])
+
+    #with open('results.json', 'w') as fp:
+    #    json.dump({'ire': ire.tolist(), 'pos': pos.tolist(),
+    #               'torq': torq.tolist(), 'psire': psire.tolist()}, fp)
+    logger.info("move steps %d currents %s", len(pos), ire[:,0])
+
+    Ai = [femagtools.utils.fft(pos, psire[:, k, 0])['a']
+          for k in range(np.shape(psire)[1])]
+    A = make_interp_spline(ire[:,0], Ai)
+    A0i = [femagtools.utils.fft(pos, psire[:, k, 0])['a0']
+           for k in range(np.shape(psire)[1])]
+    A0 = make_interp_spline(ire[:,0], A0i)
+    Bi = [femagtools.utils.fft(pos, psire[:, k, 1])['a']
+          for k in range(np.shape(psire)[1]-1, -1, -1)]
+    B = make_interp_spline(ire[::-1,1], Bi)
+    B0i = [femagtools.utils.fft(pos, psire[:, k, 1])['a0']
+           for k in range(np.shape(psire)[1]-1, -1, -1)]
+    B0 = make_interp_spline(ire[::-1,1], B0i)
+    alfa0_ai = [femagtools.utils.fft(pos, psire[:, k, 0])['alfa0']
+                for k in range(np.shape(psire)[1])]
+    alfa0_a = make_interp_spline(ire[:,0], alfa0_ai)
+    alfa0_bi = [femagtools.utils.fft(pos, psire[:, k, 1])['alfa0']
+                for k in range(np.shape(psire)[1]-1, -1, -1)]
+    alfa0_b = make_interp_spline(ire[::-1,1], alfa0_bi)
+
+    Tqi = [femagtools.utils.fft(pos, torq[:, k])['a']
+           for k in range(np.shape(torq)[1])]
+    Tq = make_interp_spline(ire[:, 0], Tqi)
+    Tq0i = [femagtools.utils.fft(pos, torq[:, k])['a0']
+            for k in range(np.shape(torq)[1])]
+    Tq0 = make_interp_spline(ire[:, 0], Tq0i)
+    alfa0_t = [femagtools.utils.fft(pos, torq[:, k])['alfa0']
+               for k in range(np.shape(torq)[1])]
+
+    T0 = np.mean([femagtools.utils.fft(pos, psire[:, k, 0])['T0']
+                  for k in range(np.shape(psire)[1])])
+    pp = 360/T0
+
+    def torque(phi, i):
+        try:
+            alfa0 = np.ones(len(i))*np.mean(alfa0_t)
+            alfa0[i < 0] = alfa0_t[0]
+            alfa0[i > 0] = alfa0_t[-1]
+        except TypeError:
+            alfa0 = np.mean(alfa0_t)
+            if i < 0:
+                alfa0 = alfa0_t[0]
+            if i > 0:
+                alfa0 = alfa0_t[-1]
+        return Tq(i)*np.cos(pp*phi+alfa0) + Tq0(i)
+
+    def psia(phi, i):
+        return A(i)*np.cos(pp*phi+alfa0_a(i))+A0(i)
+
+    def psib(phi, i):
+        return B(i)*np.cos(pp*phi+alfa0_b(i))+B0(i)
+
+    def dpsiadi(phi,i):
+        return A(i, nu=1)*np.cos(pp*phi+alfa0_a(i))+A0(i,nu=1)
+    def dpsiadphi(phi,i):
+        return -pp*A(i)*np.sin(pp*phi+alfa0_a(i))
+    def dpsibdi(phi,i):
+        return B(i, nu=1)*np.cos(pp*phi+alfa0_b(i))+B0(i,nu=1)
+    def dpsibdphi(phi,i):
+        return -pp*B(i)*np.sin(pp*phi+alfa0_b(i))
+
+    speed = simulation['speed']
+    r1 = simulation['r1']
+    l1s = simulation.get('l1s',0)
+    wm = 2*np.pi*speed
+    w1 = pp*wm
+
+    def didt(t, y):
+        return [((2*r1*y[0] + wm*(
+            dpsiadphi(y[1],y[0]) - dpsibdphi(y[1],-y[0])))/
+            (-dpsiadi(y[1],y[0]) - dpsibdi(y[1],-y[0]) -2*l1s)),
+                wm]
+    tmin = simulation.get('tstart', 0)
+    tmax = simulation.get('simultime', 0.1)
+    nsamples = simulation.get('nsamples', 400)
+    t = np.linspace(tmin, tmax, nsamples)
+
+    def func(x):
+        return B(0)*np.sin(pp*x+alfa0_b(0)) - A(0)*np.sin(pp*x+alfa0_a(0))
+    phi0 = so.fsolve(func, [0])[0]
+
+    Y0 = [0, phi0]
+    sol = ig.solve_ivp(didt, (t[0], t[-1]), Y0, dense_output=True)
+    ia = sol.sol(t).T[:, 0]
+    pv = find_peaks_and_valleys(t, ia)
+    iap = pv['tp'], pv['ip']
+    iav = pv['tv'], pv['iv']
+    iac = pv['tpeaks'][-1], pv['peaks'][-1]
+
+    logger.info("Ia %.1f %.1f %.1f (phi0 %.4f)",
+                iap[1], iav[1], iac[1], phi0)
+
+    def func(x):
+        y = torque(wm*t+phi0+x, ia)
+        pv = find_peaks_and_valleys(t, y)
+        return pv['peaks'][-1] + pv['valleys'][-1]
+
+    dphi = so.fsolve(func, [0])[0]
+    torque = torque(wm*t+phi0+dphi, ia)
+    pv = find_peaks_and_valleys(t, torque)
+    tp = pv['tp'], pv['ip']
+    tv = pv['tv'], pv['iv']
+    tc = pv['tpeaks'][-1], pv['peaks'][-1]
+    logger.info("Torque %.1f %.1f %.1f (dphi %.4f)",
+                tp[1], tv[1], tc[1], dphi)
+
+    scData = {
+        'ia': ia.tolist(),
+        'ib': (-ia).tolist(),
+        'ic': np.zeros(ia.shape).tolist(),
+        'time': t.tolist(),
+        'torque': torque.tolist(),
+        'speed': speed,
+        'ikd': iac[1],
+        'tkd': tc[1],
+        'iks': iap[1] if iap[1] > abs(iav[1]) else iav[1],
+        'tks': tp[1] if tp[1] > abs(tv[1]) else tv[1]
+    }
+    scData['peakWindingCurrents'] = [scData['iks'],
+                                     -scData['iks'], 0]
+    if simulation.get('sim_demagn', 0):
+        scData['demag'] = demag(femag, machine, simulation, engine)
+    return scData
+
+def dm_result_func(task):
+    basedir = pathlib.Path(task.directory)
+    i1rr = []
+    for f in sorted(basedir.glob('psi-torq-rem-rot-*.dat')):
+        ptr = np.loadtxt(f)
+        i1rr.append((np.max(ptr.T[1:4]), np.min(ptr.T[-1])))
+    return i1rr
+
+def demag(femag, machine, simulation, engine=0):
+    """demag simulation using psi-torq-rem-rot"""
+    logger.info("Demagnetization processing")
+    i1max = simulation['i1max']
+    i1min = simulation.get('i1min', i1max/4)
+    num_steps = 7
+    b = (i1min-i1max)/np.log(i1min/i1max)
+    a = i1max/b
+    i1tab = [b*(a+np.log(x))
+             for x in np.linspace(i1min/i1max, 1,
+                                  num_steps)]
+
+    if simulation.get('sc_type', 3) == 3:
+        curvec = [[-a/2, a, -a/2] for a in i1tab]
+    else:
+        curvec = [[a, -a, 0] for a in i1tab]
+    simulation.update({
+        'calculationMode': 'psi-torq-rem-rot',
+        'curvec': curvec})
+    if engine:
+        parstudy = _parstudy_list(femag, dm_result_func)
+        parvardef = {
+            "decision_vars": [
+                {"values": curvec, "name": "curvec"}]
+        }
+        results = parstudy(parvardef, machine, simulation, engine)
+        i1rr = np.vstack(
+            ((0, 1),
+             np.array(results['f']).reshape((-1, 2))))
+    else:
+        class Task:
+            def __init__(self, workdir):
+                self.directory = workdir
+        _ = femag(machine, simulation)
+        i1rr = np.vstack(
+            [(0, 1), dm_result_func(Task(femag.workdir))])
+    i1, rr = np.array(i1rr).T
+    dmag = {'Hk': simulation['Hk'],
+            'Tmag': simulation['Tmag'],
+            'i1': i1.tolist(),
+            'rr': rr.tolist()}
+    # critical current
+    if np.min(rr) < 0.99:
+        k = np.where(rr < 0.99)[0][0]
+        dmag['i1c'] = i1[k]
+    return dmag

femagtools/templates/psi-torq-rem-rot.mako

@@ -0,0 +1,127 @@
+-- calculate flux linkages, torque, and rel remanence (magstatic mode)
+--
+-- model:
+--    Hk (kA/m) knee point field strength
+--    curvec (A) phase current amplitude samples (list of [ía, ib, ic])
+--    num_par_wdgs (number of parallel winding groups, default 1)
+--    fc_radius (m) radius of airgap center
+--
+-- creates file psi-torq-rem-rot.dat in current directory with columns:
+--  displ curr1 curr2 curr3 psi1 psi2 psi3 torq rrem
+
+function gcd(a, b)
+	return b==0 and a or gcd(b,a%b)
+end
+
+function dmg(ek, Br, alfam, murm, Bd, Bq, Hd, Hq, alfahm, Hk)
+   if Hd < Hk then
+      muem = murm*4*math.pi*1e-7
+      Brn = Bd - Hk*1e3*muem
+      if Br < 1e-5 then
+         Brn = 1e-5
+      end
+      return Brn, alfam, 1
+   end
+   return Br, alfam, 1
+end
+
+function calc_flux_torq_rem(phi, curvec)
+    for k=1,3 do
+      def_curr_wdg(k, curvec[k]/a, 0)
+    end
+
+    dRR = 0
+    RR = 0
+    maxit=m.num_nonl_it
+    maxcop=m.error_perm -- err_perm in %
+    permode='restore'
+    repeat
+       calc_field_single({
+        maxit=maxit, maxcop=maxcop, -- err_perm in %
+        permode=permode})
+       if(maxit > 1) then
+          maxit = 1
+          permode='actual'
+          maxcop = 0.05
+       end
+       stat, RR, dRR = calc_demag(5, Hk)
+       --printf("%g %g", RR, dRR)
+    until math.abs(dRR) < 1e-5
+
+    psi = {}
+    for k=1,3 do
+      psir, psii = flux_winding_wk(k)
+      psi[k] = {ksym*psir/a*m.arm_length, ksym*psii/a*m.arm_length}
+    end
+
+    fr, ft, tq, fx, fy = force_torque()
+
+  return psi, tq, RR
+end
+%if model.get('fc_radius', 0):
+if m.fc_radius == nil then
+  m.fc_radius = ${model['fc_radius']*1e3}
+end
+%endif
+%if type(model.get('curvec')[0]) is list:
+curvec = {${','.join(['{'+','.join([str(x) for x in y])+'}' for y in model['curvec']])}} -- A
+%else:
+curvec = {{${','.join([str(x) for x in model['curvec']])}}} -- A
+%endif
+a=${model.get('num_par_wdgs', 1)}   -- parallel branches
+
+ksym = m.num_poles/m.npols_gen
+
+if num_agnodes ~= nil then
+  dphi = 360/num_agnodes -- ndst[2] -- deg
+else
+  post_models("nodedistance", "ndst" )
+  dphi = ndst[2] -- deg
+end
+nodes = math.floor(360/m.num_poles/dphi+0.5)
+printf("Nodes in airgap total %g, Nodes per pole: %d", 360/dphi, nodes)
+-- find a valid number of steps for a rotation:
+nrot = nodes
+while( nrot%2) == 0 do
+  nrot = nrot//2
+end
+-- HcB = Brem*tempcoefbr*(magn_temp-20)+1)/muerel/12.565e-7
+-- Hcmin = HcJ*tempcoefhc*(magn_temp-20.0)+1)/HcB*1e2 -- limit of demagnetization in
+Hk = ${model.get('Hk', -999)}
+Q1 = get_dev_data("num_slots")
+p = m.num_poles//2
+dphi = 360//gcd(Q1, p)/nrot
+print(string.format(" rotation steps: %d  current steps: %d\n", nrot, #curvec))
+
+phi = 0
+-- initialize rotate
+rotate({
+    airgap = m.fc_radius,    -- air gap radius
+    region = "inside",       -- region to rotate
+    mode   = "save"         -- save initial model state
+})
+
+for i=1, #curvec do
+  print(string.format(" current: %d/%d %g, %g, %g\n",
+        i, #curvec, curvec[i][1], curvec[i][2], curvec[i][3]))
+
+  file_psi = io.open("psi-torq-rem-rot-"..i..".dat","w")
+  for n=1,nrot+1 do
+    psi, tq, rr = calc_flux_torq_rem(phi, curvec[i])
+    file_psi:write(string.format("%g ", phi))
+    for k=1, 3 do
+      file_psi:write(string.format("%g ", curvec[i][k]))
+    end
+    for k=1, 3 do
+      file_psi:write(string.format("%g ", psi[k][1]))
+    end
+    file_psi:write(string.format("%g ", tq))
+    file_psi:write(string.format("%g ", rr))
+    file_psi:write("\n")
+
+    phi = n*dphi
+    rotate({angle=phi, mode="absolute"})
+  end
+  file_psi:close()
+  rotate({mode = "reset"})  -- restore the initial state (discard any changes)
+end

femagtools/templates/psi-torq-rot.mako

@@ -0,0 +1,98 @@
+-- calculate flux linkages and torque (magstatic mode)
+--
+-- model:
+--    curvec (A) current samples (amplitudes)
+--    num_par_wdgs (number of parallel winding groups, default 1)
+--
+-- creates file psi-torq-rot.dat in current directory with columns:
+--  displ curr1 curr2 curr3 psi1 psi2 psi3 torq
+--
+function gcd(a, b)
+	return b==0 and a or gcd(b,a%b)
+end
+
+function calc_flux_torq(phi, curvec)
+  psivec={}
+  tqvec={}
+  for i=1, #curvec do
+    for k=1,3 do
+      def_curr_wdg(k, curvec[i][k], 0)
+    end
+
+    calc_field_single({
+        maxit=m.num_nonl_it, maxcop=m.error_perm, -- err_perm in %
+        permode='restore'})
+    psi = {}
+    for k=1,3 do
+      psir, psii = flux_winding_wk(k)
+      psi[k] = {ksym*psir/a*m.arm_length, ksym*psii/a*m.arm_length}
+    end
+
+    fr, ft, tq, fx, fy = force_torque()
+    tqvec[i] = tq
+    psivec[i] = psi
+  end
+  return psivec, tqvec
+end
+
+%if type(model['curvec']) is list:
+curamp = {${','.join([str(x) for x in model['curvec']])}} -- A
+% else:
+curamp = {${model['curvec']}} -- A
+% endif
+a=${model.get('num_par_wdgs', 1)}   -- parallel branches
+
+curvec = {}
+for i=1, #curamp do
+    amp = curamp[i]/a
+    curvec[i] = {amp, -amp, 0}
+ end
+
+ksym = m.num_poles/m.npols_gen
+
+if num_agnodes ~= nil then
+  dphi = 360/num_agnodes -- ndst[2] -- deg
+else
+  post_models("nodedistance", "ndst" )
+  dphi = ndst[2] -- deg
+end
+nodes = math.floor(360/m.num_poles/dphi+0.5)
+printf("Nodes in airgap total %g, Nodes per pole: %d", 360/dphi, nodes)
+-- find a valid number of steps for a rotation:
+nrot = nodes
+while( nrot%2) == 0 do
+  nrot = nrot//2
+end
+Q1 = get_dev_data("num_slots")
+p = m.num_poles//2
+dphi = 360//gcd(Q1, p)/nrot
+print(string.format(" rotation steps: %d  current steps: %d\n", nrot, #curvec))
+
+phi = 0
+-- initialize rotate
+rotate({
+    airgap = m.fc_radius,    -- air gap radius
+    region = "inside",       -- region to rotate
+    mode   = "save"         -- save initial model state
+})
+
+file_psi = io.open("psi-torq-rot.dat","w")
+for n=1,nrot+1 do
+  psi, tq = calc_flux_torq(phi, curvec)
+  for i=1, #curvec do
+    file_psi:write(string.format("%g ", phi))
+    for k=1, 3 do
+      file_psi:write(string.format("%g ", a*curvec[i][k]))
+    end
+    for k=1, 3 do
+      file_psi:write(string.format("%g ", psi[i][k][1]))
+    end
+    file_psi:write(string.format("%g ", tq[i]))
+    file_psi:write("\n")
+  end
+
+  phi = n*dphi
+  rotate({angle=phi, mode="absolute"})
+end
+rotate({mode = "reset"})  -- restore the initial state (discard any changes)
+file_psi:close()

femagtools/tks.py

@@ -227,7 +227,7 @@ if __name__ == "__main__":
                                  #                                 (tks.losses['cw'],
                                  #                                  tks.losses['cw_freq'],
                                  #                                  tks.losses['b_coeff']),
-                                 title=filename, log=False)
+                                 title=filename, log=True)
         pl.show()
 
     mcv = tks.getValues()

femagtools/windings.py

@@ -46,6 +46,71 @@ def q1q2yk(Q, p, m, l=1):
     Yk = (n*qbb + 1)//pb
     return q1, q2, Yk, Qb
 
+def end_wdg_length_round_wires(layers, Rp, Rb, r_wire, h, coil_span, Q, bore_diam, slot_h1, slot_height):
+    '''return length of a single winding head for 1 coil turn.
+    Multiply by 2 to get length for both winding heads'''
+    if layers == 2:
+        R_inner_lyr = bore_diam/2 + slot_h1 + slot_height/4
+        R_outer_lyr = bore_diam/2 + slot_h1 + 3*slot_height/4
+    elif layers == 1:
+        R_inner_lyr = bore_diam/2 + slot_h1 + slot_height/2
+        R_outer_lyr = bore_diam/2 + slot_h1 + slot_height/2
+    else:
+        raise ValueError("Round wire windings can only have 1 or 2 layers")
+
+    if Rb < 2*r_wire:
+        Rb = 2*r_wire
+    if Rp < R_outer_lyr + 2*(Rb + r_wire):
+        Rp = R_outer_lyr + 2*(Rb + r_wire) + 1e-5
+    if h < 2*(Rb + r_wire):
+        h = 2*(Rb + r_wire) + 0.002
+
+    l = np.pi*coil_span/Q * (Rp + R_inner_lyr)
+    z = Rp - R_outer_lyr - 2*(Rb + r_wire)
+    l_ew = 2*h + l + z + (Rb + r_wire)*(np.pi - 2)
+    return l_ew, h, Rp, Rb
+
+def end_wdg_hairpin_check(alpha, h, dmin, l_h, wire_w, tooth_wmin):
+    alpha = alpha*np.pi/180     # ensure alpha is in radians
+    if alpha == 0 and h == 0: # end wdg parameters not set
+        alpha = np.arcsin((dmin + wire_w)/(tooth_wmin + wire_w))
+        h = np.tan(alpha)*l_h/2
+    elif alpha == 0 and h > 0: # imposed end wdg height
+        alpha = np.arctan(h/l_h)
+        dmin = np.sin(alpha)*(tooth_wmin + wire_w) - wire_w
+        if dmin < 0.0015: # imposed end wdg height is not feasible - calculate min end wdg parameters
+            dmin = 0.0015
+            alpha = np.arcsin((dmin + wire_w)/(tooth_wmin + wire_w))
+            h = np.tan(alpha)*l_h/2
+    elif alpha > 0: # imposed end wdg angle
+        dmin = np.sin(alpha)*(tooth_wmin + wire_w) - wire_w
+        if dmin < 0.0015: # imposed end wdg angle is not feasible - calculate min end wdg parameters
+            dmin = 0.0015
+            alpha = np.arcsin((dmin + wire_w)/(tooth_wmin + wire_w))
+            h = np.tan(alpha)*l_h/2
+    return h, alpha, dmin
+
+def end_wdg_length_hairpins(wire_h, wire_w, wire_th, wire_gap,
+                                 layers, coil_pitch, Q, bore_diam, slot_h, slot_w,
+                                 h_bent=0, h_welded=0, h_conn=0.005, alpha_bent=0, alpha_welded=0, dmin=0.0015): # needs to be validated
+    '''return end wdg length of single pin for bent and welded side, average end wdg length,
+     bent and welded side end wdg heights, bending angles and min distances between pins'''
+
+    R_avg = bore_diam/2 + wire_th + layers/2*(wire_h + wire_gap) + wire_h/2
+    l_h = R_avg/2*coil_pitch/Q*np.pi*(bore_diam + wire_th + slot_h)
+    tooth_wmin = (bore_diam + 2*wire_th)*np.pi/Q - slot_w
+
+    h_bent, alpha_bent, dmin = end_wdg_hairpin_check(alpha_bent, h_bent, dmin, l_h, wire_w, tooth_wmin)
+
+    h_welded = h_welded - h_conn if h_welded - h_conn > 0 else 0
+    h_welded, alpha_welded, dmin = end_wdg_hairpin_check(alpha_welded, h_welded, dmin, l_h, wire_w, tooth_wmin)
+
+    l_bent = 2*(0.002 + wire_w/2*alpha_bent + wire_w*(np.pi/2 - alpha_bent) + np.sqrt((l_h/2)**2 + h_bent**2))
+    l_welded = 2*(0.002 + wire_w/2*alpha_bent + wire_w*(np.pi/2 - alpha_bent) + np.sqrt((l_h/2)**2 + h_welded**2)) + h_conn
+    l_ew = (l_bent + l_welded)/2
+    h_welded = h_welded + h_conn
+    return l_bent, l_welded, l_ew, h_bent, h_welded, alpha_bent*180/np.pi, alpha_welded*180/np.pi, dmin
+
 
 class Winding(object):
     # TODO: raise ValueError "Unbalanced winding" if Q % (m * gcd(Q, p)) != 0

{femagtools-1.8.6.dist-info → femagtools-1.8.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: femagtools
-Version: 1.8.6
+Version: 1.8.8
 Summary: Python API for FEMAG
 Author-email: Ronald Tanner <tar@semafor.ch>, Dapu Zhang <dzhang@gtisoft.com>, Beat Holm <hob@semafor.ch>, Günther Amsler <amg@semafor.ch>, Nicolas Mauchle <mau@semafor.ch>
 License: Copyright (c) 2016-2023, Semafor Informatik & Energie AG, Basel