femagtools 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

femagtools/parstudy.py

@@ -105,10 +105,10 @@ class ParameterStudy(object):
             raise ValueError("directory {} is not empty".format(dirname))
         self.reportdir = dirname
 
-    def setup_model(self, builder, model, recsin=''):
+    def setup_model(self, builder, model, recsin='', feloss=''):
         """builds model in current workdir and returns its filenames"""
         # get and write mag curves
-        mc_files = self.femag.copy_magnetizing_curves(model, recsin=recsin)
+        mc_files = self.femag.copy_magnetizing_curves(model, recsin=recsin, feloss=feloss)
 
         if model.is_complete():
             logger.info("setup model in %s", self.femag.workdir)
@@ -192,7 +192,8 @@ class ParameterStudy(object):
                                                    objective_vars)
 
         if immutable_model:
-            modelfiles = self.setup_model(builder, model, recsin=fea.recsin)
+            modelfiles = self.setup_model(builder, model, recsin=fea.recsin,
+                                          feloss=simulation.get('feloss', ''))
             logger.info("Files %s", modelfiles+extra_files)
             logger.info("model %s", model.props())
             for k in ('name', 'poles', 'outer_diam', 'airgap', 'bore_diam',
@@ -262,6 +263,10 @@ class ParameterStudy(object):
                         p, int(np.ceil(len(par_range)/popsize)),
                         np.shape(f))
             job.cleanup()
+            try:
+                feloss = fea.calc_fe_loss
+            except AttributeError:
+                feloss = ''
             for k, x in enumerate(population):
                 task = job.add_task(self.result_func)
                 for fn in extra_files:
@@ -284,7 +289,8 @@ class ParameterStudy(object):
                     for mc in self.femag.copy_magnetizing_curves(
                             model,
                             dir=task.directory,
-                            recsin=fea.recsin):
+                            recsin=fea.recsin,
+                            feloss=feloss):
                         task.add_file(mc)
                     set_magnet_properties(model, fea, self.femag.magnets)
                     task.add_file(

femagtools/semi_fea.py

@@ -0,0 +1,108 @@
+import numpy as np 
+from .utils import fft
+import logging 
+
+logger = logging.getLogger('femagtools.semi_fea')
+
+def shift_array(v, idx): 
+    '''shift array by index'''
+    return v[idx::] + v[0:idx]
+
+def fft_filter(result_fft, perc=0.01):
+    '''filter FFT result with amplitude'''
+    result = {"order": [], "y":[]}
+    base_amp = result_fft['a']
+    for i, j in enumerate(result_fft['nue']):
+        if j >= perc*base_amp: 
+            result['order'].append(i)
+            result['y'].append(j)
+    return result
+
+def fast_skew_cogg(result, skew_setup): 
+    '''Calculate cogging torque/Back-EMF with step skewing based on unskewed result
+    Arguments: 
+    result: BCH objects 
+    skew_setup(dict): {"skew_angle": 10, "nu_skew_steps": 2}
+    '''
+    skew_angle = skew_setup['skew_angle']
+    num_skew_steps =skew_setup['num_skew_steps']
+    skew_angle_intern = 0.0
+    skew_angle_array = []
+    T_slice = []
+    bemf = {"1": [], "2": [], "3": []}
+    bemf_slice = {"1": [], "2": [], "3": []}
+    bemf_skew = {"1": [], "2": [], "3": []}
+    bemf_skew_fft = {"1": [], "2": [], "3": []}
+
+    keyset = ('1', '2', '3')
+
+    # check if skew steps equals 2
+    if num_skew_steps == 2: 
+        skew_angle_intern = skew_angle
+        skew_angle_array = [-skew_angle_intern/2, skew_angle_intern/2]
+    else: 
+        skew_angle_intern = skew_angle/num_skew_steps*(num_skew_steps-1)/2
+        skew_angle_array = np.linspace(-skew_angle_intern, skew_angle_intern, 
+                                       num_skew_steps, endpoint=True).tolist()
+
+    angle = result.torque[-1]['angle']
+    T = result.torque[-1]['torque'][0:-1]
+    # get back-emf from BCH
+    for i in keyset: 
+        bemf[i] = result.flux[i][-1]['voltage_dpsi'][0:-1]
+
+    angl_resl = angle[1]
+    tmp = np.unique(np.abs(skew_angle_array))
+    skew_angl_resl = 0.0
+    if np.amin(tmp) == 0.0: 
+        skew_angl_resl = tmp[1]
+    else: 
+        skew_angl_resl = tmp[0]
+    
+    divider = skew_angl_resl/angl_resl 
+    if divider - np.floor(divider) > 1e-15: 
+        # TODO: Interpolation if angle resolution doesn't match
+        logger.warning("Wrong Mesh Size in the airgap mesh")
+    else: 
+        logger.info(f"number of element shifted {divider}")
+
+    for i in skew_angle_array: 
+        idx = int(i/angl_resl)
+        if i != 0: 
+            T_slice.append(shift_array(T, idx))
+            for j in keyset:
+                bemf_slice[j].append(shift_array(bemf[j], idx))
+        else: 
+            # do nothing
+            T_slice.append(T)
+            for j in keyset:
+                bemf_slice[j].append(bemf[j])
+
+    # average torque
+    T_sum = 0
+    for i in T_slice: 
+        T_sum += np.array(i)
+    T_skew = (T_sum/num_skew_steps).tolist()
+    T_skew += [T_skew[0]]
+    T_fft = fft_filter(fft(angle, T_skew, pmod=2))
+
+    # average back-emf
+    for j in keyset:
+        flx_skew = 0
+        for k in bemf_slice[j]:
+            flx_skew+=np.array(k)
+        bemf_skew[j] = (flx_skew/num_skew_steps).tolist()
+        bemf_skew[j] += [bemf_skew[j][0]]
+        bemf_skew_fft[j] = fft_filter(fft(angle, bemf_skew[j], pmod=2))
+
+    for i in range(len(T_slice)):
+        T_slice[i] = (np.array(T_slice[i])/num_skew_steps).tolist()
+        T_slice[i]+=[T_slice[i][0]]
+    
+    return {"angle": angle,
+            "cogging_torque": T_skew, 
+            "cogging_torque_fft": T_fft, 
+            "BEMF": bemf_skew, 
+            "BEMF_fft": bemf_skew_fft, 
+            "cogging_torque_slice": T_slice}
+    

femagtools/templates/basic_modpar.mako

@@ -88,9 +88,6 @@ m.pole_width      = ${model['pole_width']*1e3}
 % if hasattr(model, 'lfe'):
 m.arm_length      =   ${model.get(['lfe'])*1e3}
 % endif
-% if hasattr(model, 'lfe'):
-m.arm_length      =   ${model.get(['lfe'])*1e3}
-% endif
 % if hasattr(model, 'winding'):
 % if 'num_par_wdgs' in model.winding:
 m.num_par_wdgs    = ${model.winding['num_par_wdgs']}

femagtools/templates/fe-contr.mako

@@ -1,20 +1,20 @@
-m.hc_min          =  ${'%12.3f' % model.get('hc_min', 95.0)} --   Limit demagnetisa > 0:[%]Hc,<0:[kA/m]   
-m.con_hdcopy      =  ${'%12.3f' % model.get('con_hdcopy', 0)} --   Hc-copy:Name:auto:0,intact:1, none:-1   
-m.b_max           =  ${'%12.3f' % model.get('b_max', 2.4)} --   Max Induction [T] in colorgradation     
-m.b_min           =  ${'%12.3f' % model.get('move_inside')} --   Move inside: 0 , Move outside: > 0      
-m.calc_fe_loss    =  ${'%12.3f' % model.get('calc_fe_loss', 1)} --   Calc. FE-Loss:0:no, 1:yes, 2:m-output   
-m.eval_force      =  ${'%12.3f' % model.get('eval_force', 0)} --   Eval. force density > 0, no <= 0        
-m.allow_draw      =  ${'%12.3f' % model.get('allow_draw', 1)} --   Draw Graphics :> 0: yes, 0:  no         
-m.fline_dens      =  ${'%12.3f' % model.get('fline_dens', 4)} --   F-Lines: 1: small, 2: medium, 3:thick   
-m.num_flines      =  ${'%12.3f' % model.get('num_flines', 20)} --   Number of Field-lines:      < 100 > 2   
-m.name_bch_log    =  ${'%12.3f' % model.get('name_bch_log', 0)} --   Name bch-file in Logfile:> 0:yes,0:no   
-m.st_size_move    =  ${'%12.3f' % model.get('st_size_move', 0)} --   Step size move: r/ph:[degr], x/y:[mm]   
-m.num_nonl_it     =  ${'%12.3f' % model.get('num_nonl_it', 300)} --   Number of nonlinear Iterations   < 99   
-m.perm_mode       =  ${'%12.3f' % model.get('perm_mode', 0)} --   Permeability mode:>0:restore,0:actual   
-m.error_perm      =  ${'%12.3f' % model.get('error_perm', 0.005)} --   Rel. Permeability error < 0.1     [%]   
-m.allow_demagn    =  ${'%12.3f' % model.get('allow_demagn', 0)} --   Allow Demagnetisation:= 1:yes,= 0:no    
-m.maenergy        =  ${'%12.3f' % model.get('maenergy', 0)} --   Force from magn energy 1 :yes,= 0:no    
-m.el_order_ag     =  ${'%12.3f' % model.get('el_order_ag', 1)} --   El. order in air gap: lin=1: quadr=2    
-m.export_scrpt    =  ${'%12.3f' % model.get('export_scrpt', 0)} --   Export parameters in script: yes > 0    
+m.hc_min          =  ${'%12.3f' % model.get('hc_min', 95.0)} --   Limit demagnetisa > 0:[%]Hc,<0:[kA/m]
+m.con_hdcopy      =  ${'%12.3f' % model.get('con_hdcopy', 0)} --   Hc-copy:Name:auto:0,intact:1, none:-1
+m.b_max           =  ${'%12.3f' % model.get('b_max', 2.4)} --   Max Induction [T] in colorgradation
+m.b_min           =  ${'%12.3f' % model.get('move_inside')} --   Move inside: 0 , Move outside: > 0
+m.calc_fe_loss    =  ${model.get('calc_fe_loss', 1)} --   Calc. FE-Loss:0:no, 1:yes, 2:m-output
+m.eval_force      =  ${'%12.3f' % model.get('eval_force', 0)} --   Eval. force density > 0, no <= 0
+m.allow_draw      =  ${'%12.3f' % model.get('allow_draw', 1)} --   Draw Graphics :> 0: yes, 0:  no
+m.fline_dens      =  ${'%12.3f' % model.get('fline_dens', 4)} --   F-Lines: 1: small, 2: medium, 3:thick
+m.num_flines      =  ${'%12.3f' % model.get('num_flines', 20)} --   Number of Field-lines:      < 100 > 2
+m.name_bch_log    =  ${'%12.3f' % model.get('name_bch_log', 0)} --   Name bch-file in Logfile:> 0:yes,0:no
+m.st_size_move    =  ${'%12.3f' % model.get('st_size_move', 0)} --   Step size move: r/ph:[degr], x/y:[mm]
+m.num_nonl_it     =  ${'%12.3f' % model.get('num_nonl_it', 300)} --   Number of nonlinear Iterations   < 99
+m.perm_mode       =  ${'%12.3f' % model.get('perm_mode', 0)} --   Permeability mode:>0:restore,0:actual
+m.error_perm      =  ${'%12.3f' % model.get('error_perm', 0.005)} --   Rel. Permeability error < 0.1     [%]
+m.allow_demagn    =  ${'%12.3f' % model.get('allow_demagn', 0)} --   Allow Demagnetisation:= 1:yes,= 0:no
+m.maenergy        =  ${'%12.3f' % model.get('maenergy', 0)} --   Force from magn energy 1 :yes,= 0:no
+m.el_order_ag     =  ${'%12.3f' % model.get('el_order_ag', 1)} --   El. order in air gap: lin=1: quadr=2
+m.export_scrpt    =  ${'%12.3f' % model.get('export_scrpt', 0)} --   Export parameters in script: yes > 0
 
 pre_models("FE-contr-data")

femagtools/templates/ld_lq_fast.mako

@@ -21,6 +21,9 @@ m.num_cur_steps   =    ${model['num_cur_steps']}
 m.nu_beta_steps   =    ${model['num_beta_steps']}
 m.beta_max        =    ${model['beta_max']}
 m.beta_min        =    ${model['beta_min']}
+% if model.get('calc_fe_loss', 0):
+m.calc_fe_loss    =  ${model['calc_fe_loss']}
+% endif
 % if  model.get('loss_funct',0):
 m.loss_funct      =    ${model.get('loss_funct')}
 % endif

femagtools/templates/mesh-airgap.mako

@@ -44,10 +44,16 @@ if not airgap_created then
     nc_line(r2, 0.0, x2, y2, 0.0)
 
     if m.tot_num_slot > m.num_sl_gen then
+      if inner_da_end == nil then
+        inner_da_end = inner_da_start
+      end
       x3, y3 = pr2c(inner_da_end, alfa)
       x4, y4 = pr2c(r1, alfa)
       nc_line(x3, y3, x4, y4, 0, 0)
 
+      if outer_da_end == nil then
+        outer_da_end = outer_da_start
+      end
       x3, y3 = pr2c(outer_da_end, alfa)
       x4, y4 = pr2c(r2, alfa)
       nc_line(x3, y3, x4, y4, 0, 0)

femagtools/templates/mult_cal_fast.mako

@@ -22,6 +22,9 @@ m.fc_mult_move_type =  1.0 --  Type of move path in air gap
 m.fc_force_points   =  0.0 --    number move points in air gap
 m.loss_funct    = ${model.get('loss_funct', 0)}     -- loss functon 0: own 1: ext
 m.loss_fact     = ${model.get('loss_fact', 1)}   -- loss multiplication factor
+% if model.get('calc_fe_loss', 0):
+m.calc_fe_loss    =  ${model['calc_fe_loss']}
+% endif
 
 % if model.get('vtu_movie', 0):
 m.movie_type = 'vtu'

femagtools/templates/pm_sym_f_cur.mako

@@ -23,11 +23,14 @@ m.pocfilename    = '${model.get('pocfilename', 'sin.poc')}'
 % if model.get('vtu_movie', 0):
 m.movie_type = 'vtu'
 %endif
+% if model.get('calc_fe_loss'):
+m.calc_fe_loss    =  ${'%d' % model['calc_fe_loss']}
+% endif
 % if  model.get('loss_funct',0):
 m.loss_funct      =    ${model.get('loss_funct')}
 % endif
 -- Excitation current
-m.nloa_ex_cur   = ${model.get('nload_ex_cur', 0)} -- No Load Exciting current
+m.nloa_ex_cur   = ${model.get('noload_ex_cur', 0)} -- No Load Exciting current
 m.load_ex_cur   = ${model.get('load_ex_cur', 0)} -- Load Exciting current
 m.wdgkeyex      =  0 -- automatic winding selection
 

femagtools/templates/pm_sym_fast.mako

@@ -7,6 +7,9 @@ set_sim_data("explicit_mode", ${model.get('explicit_mode',0)})
 % if model.get('wind_temp',0):
 set_dev_data("cond_temp", ${model.get('wind_temp')}, ${model.get('wind_temp')})
 % endif
+% if model.get('calc_fe_loss', 0):
+m.calc_fe_loss    =  ${model['calc_fe_loss']}
+% endif
 m.move_action     =    ${model.get('move_action', 0)}
 % if  model.get('lfe',0):
 m.arm_length      =    ${model.get('lfe')*1e3}

femagtools/templates/pm_sym_loss.mako

@@ -20,6 +20,9 @@ m.winding_temp    =    ${model.get('wind_temp')}
 m.current         =    1.0
 m.ntibfilename    =    model..'.ntib'
 m.period_frac     =    ${model.get('period_frac', 1)}
+% if model.get('calc_fe_loss', 0):
+m.calc_fe_loss    =  ${model['calc_fe_loss']}
+% endif
 % if  model.get('loss_funct',0):
 m.loss_funct      =    ${model.get('loss_funct')}
 % endif

femagtools/templates/psd_psq_fast.mako

@@ -24,6 +24,9 @@ m.delta_iq        =    ${model['delta_iq']}/m.num_par_wdgs
 % if model.get('load_ex_cur',0):
 m.load_ex_cur     =    ${model['load_ex_cur']}
 %endif
+% if model.get('calc_fe_loss', 0):
+m.calc_fe_loss    =  ${model['calc_fe_loss']}
+% endif
 % if  model.get('loss_funct',0):
 m.loss_funct      =    ${model.get('loss_funct')}
 % endif

femagtools/templates/torq_calc.mako

@@ -2,6 +2,9 @@
 -- Torque/Force calculation
 --
 m.move_action     =    ${model.get('move_action', 0)}
+% if model.get('calc_fe_loss', 0):
+m.calc_fe_loss    =  ${model['calc_fe_loss']}
+% endif
 % if  model.get('loss_funct',0):
 m.loss_funct      =    ${model.get('loss_funct')}
 % endif

femagtools/tks.py

@@ -22,15 +22,15 @@ HBpattern = re.compile(r'H.+\s+B')
 BPpattern = re.compile(r'B.+\s+P')
 
 _tranlate = {
-    "ch": "Hysteresis Loss Factor", 
-    "cw": "Eddy Current Loss Factor", 
-    "ce": "Excess Loss Factor", 
-    "ch_freq": "Hyteresis Exponent", 
-    "cw_freq": "Eddy Current Exponent", 
-    "b_coeff": "Induction Loss Exponent", 
+    "ch": "Hysteresis Loss Factor",
+    "cw": "Eddy Current Loss Factor",
+    "ce": "Excess Loss Factor",
+    "ch_freq": "Hyteresis Exponent",
+    "cw_freq": "Eddy Current Exponent",
+    "b_coeff": "Induction Loss Exponent",
     "alpha": "Induction Loss Exponent (Bertotti)",
-    "Bo": "Reference Induction", 
-    "fo": "Reference Frequency", 
+    "Bo": "Reference Induction",
+    "fo": "Reference Frequency",
 }
 
 def readlist(section):
@@ -134,15 +134,15 @@ class Reader(object):
             self.losses['cw_freq'] = z[1]
             self.losses['b_coeff'] = z[2]
 
-            self.steinmetz = {'cw': z[0], 'cw_freq': z[1], 'b_coeff': z[2], 
+            self.steinmetz = {'cw': z[0], 'cw_freq': z[1], 'b_coeff': z[2],
                               'Bo': self.Bo, 'fo': self.fo}
 
             self.losses['Bo'] = self.Bo
             self.losses['fo'] = self.fo
             z = lc.fit_bertotti(self.losses['f'],
                                 self.losses['B'], pfe)
-            self.bertotti = {'ch': z[0], 'cw': z[1], 'ce': z[2], 
-                             'alpha': 2.0, 'Bo': 1, 'fo': 1}
+            self.bertotti = {'ch': z[0], 'cw': z[1], 'ce': z[2],
+                             'b_coeff': 2.0, 'Bo': 1, 'fo': 1}
             logger.info("Bertotti loss coeffs %s", z)
 
             # must normalize pfe matrix:
@@ -171,9 +171,12 @@ class Reader(object):
             'cw_freq': self.cw_freq,
             'b_coeff': self.b_coeff,
             'rho': self.rho,
-            'losses': self.losses}
-    
-def tableview(Reader): 
+            'losses': self.losses,
+            'bertotti': self.bertotti,
+            'steinmetz': self.steinmetz,
+            'jordan': self.jordan}
+
+def tableview(Reader):
     """pretty print loss coeff table"""
     losscoeff = [Reader.jordan, Reader.steinmetz, Reader.bertotti]
     # Title
@@ -181,18 +184,18 @@ def tableview(Reader):
     print('='*strlen)
     print('| {:^34} '.format(' ') + '| {:^18} | {:^18} | {:^18} |'.format(*["Jordan", "Steinmetz", 'Bertotti']))
     print('='*strlen)
-    # data 
-    for key, item in _tranlate.items(): 
+    # data
+    for key, item in _tranlate.items():
         fout = ''
-        for i in losscoeff: 
-            if key in i: 
+        for i in losscoeff:
+            if key in i:
                 fout += '| ' + f'{i[key]:^18.8e} '
-            else: 
+            else:
                 tmp = '-'
                 fout += '| ' + f'{tmp:^18} '
         print(f'| {item:^34}' + ' ' + fout + '|')
         print('='*strlen)
-    return 
+    return
 
 def read(filename, filecontent=None):
     """read Thyssen File TKS and return mc dict"""

femagtools/utils.py

@@ -17,7 +17,7 @@ def fft(pos, y, pmod=0):
     else:
         #negative_periodic = np.abs(y[0] - y[-1])/np.max(y) > 1
         # count zero crossings
-        ypos = np.asarray(y[:-1]) > 0
+        ypos = np.asarray(y[:-1])-np.mean(y[:-1]) > 0
         nypos = ~ypos
         nzc = len(((ypos[:-1] & nypos[1:])
                    | (nypos[:-1] & ypos[1:])).nonzero()[0])

femagtools/windings.py

@@ -179,10 +179,10 @@ class Winding(object):
             nue = n
         else:
             nue = self.kw_order(n)
-        #if q1 == q2:  # integral slot winding
-        #    q = self.Q/2/self.m/self.p
-        #    nuep = nue/self.p
-        #    return np.sin(nuep*np.pi/2/self.m)/q/np.sin(nuep*np.pi/2/self.m/q)
+        if q1 == q2:  # integral slot winding
+            q = self.Q/2/self.m/self.p
+            nuep = nue/self.p
+            return np.sin(nuep*np.pi/2/self.m)/q/np.sin(nuep*np.pi/2/self.m/q)
         k = 2 if self.l == 1 else 1
         a = nue*k*np.pi/self.Q*Yk
         t = self.Q//Qb
@@ -416,6 +416,13 @@ class Winding(object):
              [[d*s for s, d in zip(l, ld)] for l, ld in zip(lower, ldirs)])
         # complete if not  basic winding:
         Qb = self.Q//num_basic_windings(self.Q, self.p, self.l)
+
+        if not np.asarray(upper).size or not np.asarray(lower).size:
+            layers = 1
+        if layers == 1 and z[1]:
+            z = ([[d*s for s, d in zip(l, ld)] for l, ld in zip(lower, ldirs)],
+                 [[d*s for s, d in zip(u, ud)] for u, ud in zip(upper, udirs)])
+
         if max([abs(n) for m in z[0] for n in m]) < Qb:
             return [[k + [-n+Qb//2 if n < 0 else -(n+Qb//2) for n in k]
                      for k in m] for m in z]

femagtools/zmq.py

@@ -0,0 +1,213 @@
+"""zmq functions for FEMAG
+
+"""
+import re
+import pathlib
+import threading
+import json
+import time
+import logging
+try:
+    import zmq
+except ImportError:
+    pass
+
+numpat = re.compile(r'([+-]?\d+(?:\.\d+)?(?:[eE][+-]\d+)?)\s*')
+logger = logging.getLogger(__name__)
+
+class ProtFile:
+    def __init__(self, dirname, num_cur_steps):
+        self.size = 0
+        self.looplen = 0
+        self.cur_steps = [1, num_cur_steps]
+        self.n = 0
+        self.num_loops = 0
+        import platform
+        self.dirname = dirname
+        self.name = 'samples'
+
+    def percent(self):
+        if self.looplen > 0:
+            return min(100 * self.n / self.looplen, 100)
+        return 0
+
+    def update(self):
+        if not self.dirname:
+            return ''
+        p = list(pathlib.Path(self.dirname).glob('*.PROT'))
+        if p:
+            buf = ''
+            if self.size < p[0].stat().st_size:
+                with p[0].open() as fp:
+                    fp.seek(self.size)
+                    buf = fp.read()
+            return self.append(buf)
+        return ''
+
+    def append(self, buf):
+        self.size += len(buf)
+        for line in [l.strip() for l in buf.split('\n') if l]:
+            if line.startswith('Loop'):
+                self.n = 0
+                try:
+                    cur_steps = self.cur_steps[self.num_loops]
+                except IndexError:
+                    cur_steps = 1
+                x0, x1, dx, nbeta = [float(f)
+                                     for f in re.findall(numpat, line)][:4]
+                move_steps = round((x1-x0)/dx+1)
+                beta_steps = int(nbeta)
+                self.looplen = cur_steps*beta_steps*move_steps
+                self.num_loops += 1
+            elif (line.startswith('Cur') or
+                  line.startswith('Id')):
+                self.n += 1
+            elif line.startswith('Number movesteps Fe-Losses'):
+                return f'{self.percent():3.1f}%' # 100%
+            elif line.startswith('begin'):
+                self.name = line.split()[1].strip()
+
+        return f'{self.percent():3.1f}%'  # {self.n}/{self.looplen}'
+
+
+class SubscriberTask(threading.Thread):
+    ylabel_index = 1
+    curve_label = '{}.'
+    # used by static notify func
+    percent_list = []
+    notify_timerfunc = None
+    notify_send_loop = True
+    notify = None
+    notify_send_header = set()
+    notify_send_data = dict()
+
+    def __init__(self, **kwargs):
+        threading.Thread.__init__(self)
+        context = zmq.Context.instance()
+        self.subscriber = context.socket(zmq.SUB)
+        self.port = kwargs.get('port', None)
+        self.host = kwargs.get('host')
+        self.notify = kwargs.get('notify', None)
+        SubscriberTask.notify = kwargs.get('notify', None)
+        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)
+        if not self.host:
+            self.host = 'localhost'
+        if not self.header:
+            self.header = [b'']
+        self.running = True
+
+        # timer function
+        if not SubscriberTask.notify_timerfunc:
+            SubscriberTask.notify_timerfunc = threading.Timer(0.1, SubscriberTask.send_notify)
+            SubscriberTask.notify_send_loop = True
+            SubscriberTask.notify_timerfunc.start()
+
+        if b'xyplot' in self.header:
+            self.ylabel = self.curve_label.format(SubscriberTask.ylabel_index)
+            SubscriberTask.ylabel_index += 1
+        if b'progress' in self.header:
+            self.protfile = ProtFile(None, self.num_cur_steps)
+            self.protId = len(SubscriberTask.percent_list)
+            SubscriberTask.percent_list.append(0)  # 0%
+
+        self.subscriber.connect(f'tcp://{self.host}:{self.port}')
+        self.subscriber.setsockopt(zmq.SUBSCRIBE, self.header[0] if len(self.header) == 1 else b'')
+        self.controller = zmq.Context.instance().socket(zmq.PULL)
+        self.controller_url = f'inproc://publisher{self.port}'
+        try:
+            self.controller.bind(self.controller_url)
+        except zmq.error.ZMQError:
+            pass # ignore
+
+        self.poller = zmq.Poller()
+        self.poller.register(self.subscriber, zmq.POLLIN)
+        self.poller.register(self.controller, zmq.POLLIN)
+        self.logger = logger
+
+    def stop(self):
+        socket = zmq.Context.instance().socket(zmq.PUSH)
+        socket.connect(self.controller_url)
+        socket.send(b"quit")
+        socket.close()
+        self.running = False
+
+    def clear():
+        SubscriberTask.ylabel_index = 1
+        SubscriberTask.curve_label = '{}.'
+        SubscriberTask.notify_timerfunc = None
+        SubscriberTask.notify_send_loop = False
+        SubscriberTask.notify = None
+        SubscriberTask.notify_send_header = set()
+        SubscriberTask.notify_send_data = dict()
+        SubscriberTask.percent_list = []
+
+    def send_notify():
+        logger.debug(f"Send loop: {SubscriberTask.notify_send_loop}")
+        while SubscriberTask.notify_send_loop:
+            logger.debug(f"Send data: {SubscriberTask.notify_send_header}")
+            if 'progress_logger' in SubscriberTask.notify_send_header:
+                # collect data from different threads
+                SubscriberTask.notify_send_header.remove('progress_logger')
+                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}"
+                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')
+
+            time.sleep(abs(SubscriberTask.timestep))
+        logger.debug(f"Send Finished loop: {SubscriberTask.notify_send_loop}")
+
+    def run(self):
+        self.logger.debug("subscriber is ready, port: %s", {self.port})
+        while self.running:
+            socks = dict(self.poller.poll())
+            if socks.get(self.subscriber) == zmq.POLLIN:
+                try:
+                    response = self.subscriber.recv_multipart()
+                    # Sometimes femag send messages with only len = 1. These messages must be ignored
+                    if len(response) < 2:
+                        continue
+                    # header progress
+                    if response[0] == b'progress' and b'progress' in self.header:
+                        SubscriberTask.notify_send_header.add('progress_logger')
+                        response[0] = b'progress_logger'
+                        SubscriberTask.notify_send_data['progress_logger'] = response
+                        SubscriberTask.percent_list[self.protId] = json.loads(response[1].decode()).get('percent')
+                        continue
+
+                    # header xyplot (add ylabel)
+                    if response[0] == b'xyplot' and b'xyplot' in self.header    :
+                        d = json.loads(response[1].decode(), strict=False)
+                        d['ylabel'] = f"{d.get('ylabel')}_{self.ylabel}" \
+                            if d.get('ylabel') else self.ylabel
+                        response[1] = json.dumps(d).encode()
+
+                        # timestep negative, immediately update
+                        if SubscriberTask.timestep < 0:
+                            self.notify([s.decode('latin1') for s in response])
+                        else:
+                            SubscriberTask.notify_send_data['xyplot'] = response
+                            SubscriberTask.notify_send_header.add('xyplot')
+                        continue
+
+                    if response[0] in self.header or b'' in self.header:
+                        self.notify([s.decode('latin1') for s in response])
+
+                except Exception:
+                    self.logger.error(
+                        "error in subscription message processing", exc_info=True)
+
+            if socks.get(self.controller) == zmq.POLLIN:
+                req = self.controller.recv()
+                self.logger.info("subscriber %s", req)
+                break
+        self.subscriber.close()
+        self.controller.close()
+        self.logger.debug("subscriber stopped")

{femagtools-1.8.2.dist-info → femagtools-1.8.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: femagtools
-Version: 1.8.2
+Version: 1.8.4
 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
@@ -37,7 +37,7 @@ Classifier: Topic :: Scientific/Engineering
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: numpy<=1.26.4
+Requires-Dist: numpy
 Requires-Dist: scipy
 Requires-Dist: mako
 Requires-Dist: six