femagtools 1.8.1__py3-none-any.whl → 1.8.3__py3-none-any.whl

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/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/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.1.dist-info → femagtools-1.8.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: femagtools
-Version: 1.8.1
+Version: 1.8.3
 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