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

femagtools/multiproc.py

@@ -12,6 +12,8 @@ import pathlib
 import logging
 from .job import Job
 import femagtools.config as cfg
+import femagtools.zmq
+from femagtools.zmq import SubscriberTask
 try:
     from subprocess import DEVNULL
 except ImportError:
@@ -19,86 +21,40 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
-numpat = re.compile(r'([+-]?\d+(?:\.\d+)?(?:[eE][+-]\d+)?)\s*')
-
 class LicenseError(Exception):
     pass
 
-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
-        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):
-        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 ''
-            elif line.startswith('begin'):
-                self.name = line.split()[1].strip()
-
-        return f'{self.percent():3.1f}%'  # {self.n}/{self.looplen}'
-
-
 class ProgressLogger(threading.Thread):
-    def __init__(self, dirs, num_cur_steps, timestep):
+    def __init__(self, dirs, num_cur_steps, timestep, notify):
         threading.Thread.__init__(self)
-        self.dirs = dirs
-        self.num_cur_steps = num_cur_steps
+        self.protfiles = [femagtools.zmq.ProtFile(d, num_cur_steps)
+                          for d in dirs]
+        self.numTot = len(dirs)
         self.running = False
         self.timestep = timestep
+        self.notify = notify
 
     def run(self):
         self.running = True
-        protfiles = [ProtFile(d, self.num_cur_steps)
-                     for d in self.dirs]
         while self.running:
-            time.sleep(self.timestep)
-            logmsg = [p.update() for p in protfiles]
+            if self.timestep > 0:
+                time.sleep(self.timestep)
+            logmsg = [p.update() for p in self.protfiles]
             summary = [l  # f'<{i}> {l}'
                        for i, l in enumerate(logmsg)
                        if l]
             if summary:
-                labels = set([p.name for p in protfiles])
+                labels = set([p.name for p in self.protfiles])
                 logger.info('%s: %s',
                             ', '.join(labels),
                             ', '.join(summary))
+                if self.notify:
+                    numOf = f"{summary.count('100.0%')} of {self.numTot}"
+                    percent = sum([float(i[:-1])
+                                   for i in summary]) / self.numTot
+                    self.notify(
+                        ["progress_logger",
+                         f"{self.numTot}:{numOf}:{percent}:{' '.join(summary)}"])
             else:
                 logger.info('collecting FE losses ...')
                 return
@@ -107,7 +63,7 @@ class ProgressLogger(threading.Thread):
         self.running = False
 
 
-def run_femag(cmd, workdir, fslfile):
+def run_femag(cmd, workdir, fslfile, port):
     """Start the femag command as subprocess.
 
     :internal:
@@ -120,7 +76,8 @@ def run_femag(cmd, workdir, fslfile):
     with open(os.path.join(workdir, "femag.out"), "wb") as out, \
             open(os.path.join(workdir, "femag.err"), "wb") as err:
         try:
-            proc = subprocess.Popen(cmd + ['-b', fslfile],
+            args = ['-b', str(port), fslfile] if port else ['-b', fslfile]
+            proc = subprocess.Popen(cmd + args,
                                     shell=False,
                                     stdin=DEVNULL,
                                     stdout=out,
@@ -163,11 +120,16 @@ class Engine:
         cmd: the program (executable image) to be run
             (femag dc is used if None)
         process_count: number of processes (cpu_count() if None)
-        progress_timestep: time step in seconds for progress log messages if > 0)
+        timestep: time step in seconds for progress log messages if > 0)
     """
 
     def __init__(self, **kwargs):
         self.process_count = kwargs.get('process_count', None)
+        self.notify = kwargs.get('notify', None)
+        # cogg_calc mode, subscribe xyplot
+        self.calc_mode = kwargs.get('calc_mode')
+        self.port = kwargs.get('port', 0)
+        self.curve_label = kwargs.get('curve_label')
         cmd = kwargs.get('cmd', '')
         if cmd:
             self.cmd = [cmd]
@@ -175,7 +137,10 @@ class Engine:
                 self.cmd.append('-m')
 
         self.progressLogger = 0
-        self.progress_timestep = kwargs.get('timestep', 5)
+        self.progress_timestep = kwargs.get('timestep', -1)
+        self.subscriber = None
+        self.job = None
+        self.tasks = []
 
     def create_job(self, workdir):
         """Create a FEMAG :py:class:`Job`
@@ -209,20 +174,41 @@ class Engine:
                 t.cmd = [cfg.get_executable(
                     t.stateofproblem)] + args
 
-        self.pool = multiprocessing.Pool(self.process_count)
-        self.tasks = [self.pool.apply_async(run_femag,
-                                            args=(t.cmd,
-                                                  t.directory,
-                                                  t.fsl_file))
-                      for t in self.job.tasks]
+        num_proc = self.process_count
+        if not num_proc and multiprocessing.cpu_count() > 1:
+            num_proc = min(multiprocessing.cpu_count()-1, len(self.job.tasks))
+        self.pool = multiprocessing.Pool(num_proc)
+        if self.port:
+            header = [b'progress']
+            if self.calc_mode == 'cogg_calc':
+                header +=[b'xyplot']
+            self.subscriber = [SubscriberTask(port=self.port + i * 5,
+                                              host='127.0.0.1',
+                                              notify=self.notify,
+                                              header=header,
+                                              curve_label=self.curve_label,
+                                              num_cur_steps=self.job.num_cur_steps,
+                                              timestep=self.progress_timestep
+                                              )
+                               for i, t in enumerate(self.job.tasks)]
+            [s.start() for s in self.subscriber]
+            self.tasks = [self.pool.apply_async(
+                run_femag, args=(t.cmd, t.directory, t.fsl_file, self.port + i * 5))
+                          for i, t in enumerate(self.job.tasks)]
+        else:
+            self.tasks = [self.pool.apply_async(
+                run_femag, args=(t.cmd, t.directory, t.fsl_file, 0))
+                          for t in self.job.tasks]
         self.pool.close()
 
-        if (self.progress_timestep and
-                self.job.num_cur_steps):
+        # only works on linux
+        if (self.progress_timestep and not self.port and
+            self.job.num_cur_steps):
             self.progressLogger = ProgressLogger(
                 [t.directory for t in self.job.tasks],
                 num_cur_steps=self.job.num_cur_steps,
-                timestep=self.progress_timestep)
+                timestep=self.progress_timestep,
+                notify=self.notify)
             self.progressLogger.start()
         return len(self.tasks)
 
@@ -244,17 +230,30 @@ class Engine:
                     if t.errmsg:
                         logger.error(t.errmsg)
             status.append(t.status)
+        self.stopThreads()
+        self.pool = None # garbage collector deletes threads
+        return status
+
+    def stopThreads(self):
+        """ stop all running treads
+        """
         if self.progressLogger:
             self.progressLogger.stop()
-        return status
+        if self.port and self.subscriber:
+            [s.stop() for s in self.subscriber]
+            SubscriberTask.clear()
+            self.subscriber = None
 
     def terminate(self):
+        """ terminate all
+        """
         logger.info("terminate Engine")
-        if self.progressLogger:
-            self.progressLogger.stop()
+        self.stopThreads()
+
         # terminate pool
         try:
-            self.pool.terminate()
-            self.pool.close()
+            if self.pool:
+                self.pool.terminate()
+                self.pool = None # garbage collector deletes threads
         except AttributeError as e:
             logger.warn("%s", e)

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/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"""