femagtools 1.8.5__py3-none-any.whl → 1.8.7__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/utils.py

@@ -49,7 +49,9 @@ def fft(pos, y, pmod=0):
         nmax = min(9*npoles, N//2)
 
     alfa0 = np.angle(Y[i])
+    alfa = np.angle(Y[:nmax])
 
     return {'a': a, 'a0': a0, 'T0': T0, 'alfa0': alfa0,
+            'alfa': alfa,
             'nue': (2*np.abs(Y[:nmax])/N).tolist(),
             'yi': yx.tolist()}

femagtools/zmq.py

@@ -80,6 +80,9 @@ class SubscriberTask(threading.Thread):
     notify = None
     notify_send_header = set()
     notify_send_data = dict()
+    # progress, xydata and this entries of this list
+    # will send only only once per timestep
+    simple_data = ['license']
 
     def __init__(self, **kwargs):
         threading.Thread.__init__(self)
@@ -92,7 +95,8 @@ class SubscriberTask(threading.Thread):
         self.header = kwargs.get('header')
         self.num_cur_steps = kwargs.get('num_cur_steps', None)
         SubscriberTask.curve_label = kwargs.get('curve_label', '')
-        SubscriberTask.timestep = kwargs.get('timestep', 1)
+        SubscriberTask.timestep = kwargs.get('timestep', 2)
+
         if not self.host:
             self.host = 'localhost'
         if not self.header:
@@ -145,7 +149,7 @@ class SubscriberTask(threading.Thread):
         SubscriberTask.percent_list = []
 
     def send_notify():
-        logger.debug(f"Send loop: {SubscriberTask.notify_send_loop}")
+        logger.debug(f"Send loop: {SubscriberTask.notify_send_loop}, timestep: {SubscriberTask.timestep}")
         while SubscriberTask.notify_send_loop:
             if 'progress_logger' in SubscriberTask.notify_send_header:
                 # collect data from different threads
@@ -153,13 +157,20 @@ class SubscriberTask(threading.Thread):
                 numTot = len(SubscriberTask.percent_list)
                 d = json.loads(SubscriberTask.notify_send_data.get('progress_logger')[1])
                 d['percent'] = sum(SubscriberTask.percent_list) / numTot
-                d['subtitle'] = f"{SubscriberTask.percent_list.count(100)} of {numTot}"
+                d['subtitle'] = f"{SubscriberTask.percent_list.count(100)} of {numTot}" if numTot > 1 else ''
                 SubscriberTask.notify(['progress_logger', json.dumps(d)])
             if 'xyplot' in SubscriberTask.notify_send_header:
                 SubscriberTask.notify([s.decode('latin1')
                                        for s in SubscriberTask.notify_send_data.get('xyplot')])
                 SubscriberTask.notify_send_header.remove('xyplot')
 
+            # simple
+            for sdata in SubscriberTask.simple_data:
+                if sdata in SubscriberTask.notify_send_header:
+                    SubscriberTask.notify([s.decode('latin1')
+                                           for s in SubscriberTask.notify_send_data.get(sdata)])
+                    SubscriberTask.notify_send_header.remove(sdata)
+
             time.sleep(abs(SubscriberTask.timestep))
         logger.debug(f"Send Finished loop: {SubscriberTask.notify_send_loop}")
 
@@ -196,7 +207,14 @@ class SubscriberTask(threading.Thread):
                             SubscriberTask.notify_send_header.add('xyplot')
                         continue
 
-                    if response[0] in self.header or b'' in self.header:
+                    # simple
+                    for sdata in SubscriberTask.simple_data:
+                        if response[0] == sdata.encode() and sdata.encode() in self.header:
+                            SubscriberTask.notify_send_header.add(sdata)
+                            SubscriberTask.notify_send_data[sdata] = response
+                            continue
+
+                    if response[0] not in self.header:
                         self.notify([s.decode('latin1') for s in response])
 
                 except Exception:

{femagtools-1.8.5.dist-info → femagtools-1.8.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: femagtools
-Version: 1.8.5
+Version: 1.8.7
 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