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

femagtools/mcv.py

@@ -8,6 +8,7 @@ import sys
 import copy
 import logging
 import os.path
+import pathlib
 import struct
 import math
 import numpy as np
@@ -292,7 +293,12 @@ class Mcv(object):
         self.MC1_CW_FREQ_FACTOR = 0.0
         self.MC1_INDUCTION_FACTOR = 0.0
         self.MC1_INDUCTION_BETA_FACTOR = 0.0
-
+        self.jordan = {}
+        # {'ch': 0, 'cw': 0, 'ch_freq':0, 'cw_freq':0}
+        self.steinmetz = {}
+        # {'ch': 0, 'cw': 0, 'ch_freq':0, 'cw_freq':0}
+        self.bertotti = {}
+        # {'ch': 0, 'cw': 0, 'ce':0, 'ch_freq':0, 'cw_freq':0}
         self.MC1_FE_SPEZ_WEIGTH = 7.65
         self.MC1_FE_SAT_MAGNETIZATION = 2.15
 
@@ -335,9 +341,8 @@ class Mcv(object):
             self.setData(data)
 
             self.mc1_curves = len(self.curve)
-            if self.mc1_type == MAGCRV and self.mc1_curves > 1:
-                self.mc1_type = ORIENT_CRV
-            if self.mc1_type in (ORIENT_CRV, ORIENT_PM_CRV):
+            if (self.mc1_type in (ORIENT_CRV, ORIENT_PM_CRV)
+                or self.mc1_curves > 1):
                 self.version_mc_curve = self.ORIENTED_VERSION_MC_CURVE
             elif self.mc1_type == DEMCRV_BR:
                 self.version_mc_curve = self.PARAMETER_PM_CURVE
@@ -355,6 +360,9 @@ class Mcv(object):
         for k in wtrans:
             if wtrans[k] in data.keys():
                 self.__setattr__(k, data[wtrans[k]])
+        for k in ('bertotti', 'jordan', 'steinmetz'):
+            if k in data:
+                self.__setattr__(k, data[k])
         self.curve = data['curve']
         try:
             self.mc1_angle = [c['angle'] for c in data['curve']]
@@ -364,6 +372,9 @@ class Mcv(object):
             self.losses = data['losses']
         except Exception:
             pass
+        # assume jordan iron loss parameters
+        for k in self.jordan:
+            self.jordan[k] = getattr(self, transl[k])
         return
 
     def rtrimValueList(self, vlist):
@@ -471,13 +482,25 @@ class Writer(Mcv):
                        for c in curve]
         return curve
 
-    def writeBinaryFile(self, fillfac=None, recsin=''):
+    def writeBinaryFile(self, fillfac=None, recsin='', feloss=''):
         """write binary file after conversion if requested.
         arguments:
         fillfac: (float) fill actor
         recsin: (str) either 'flux' or 'cur'
+        feloss: (str) iron loss method (bertotti, jordan)
         """
         curve = self._prepare(fillfac, recsin)
+        try:
+            if feloss.lower() == 'bertotti':
+                for k in self.bertotti:
+                    setattr(self, transl[k], self.bertotti[k])
+                del self.losses
+            else:
+                for k in self.jordan:
+                    setattr(self, transl[k], self.jordan[k])
+        except AttributeError as e:
+            logger.warning("%s", e)
+            pass
         mc1_type = self.mc1_type
         mc1_recalc = self.mc1_recalc
         mc1_fillfac = self.mc1_fillfac
@@ -557,6 +580,7 @@ class Writer(Mcv):
 
         try:
             if not (self.mc1_ch_factor or self.mc1_cw_factor) and self.losses:
+                # fit loss parameters
                 pfe = self.losses['pfe']
                 f = self.losses['f']
                 B = self.losses['B']
@@ -599,7 +623,8 @@ class Writer(Mcv):
             return
 
         try:
-            nfreq = len([1 for x in self.losses['f'] if x > 0])
+            freq = [x for x in self.losses['f'] if x > 0]
+            nfreq = len(freq)
             nind = len(self.losses['B'])
             if nind < 1 or nfreq < 1:
                 return
@@ -632,26 +657,28 @@ class Writer(Mcv):
             self.writeBlock([nfreq, nind])
             self.writeBlock([float(b) for b in B] + [0.0]*(M_LOSS_INDUCT - nind))
 
+            nrec = 0
             for f, p in zip(self.losses['f'], pfe):
                 if f > 0:
                     y = np.array(p)
                     losses = [float(x) for x in y[y != np.array(None)]]
-                    if len(losses) == nind:
-                        pl = p
+                    nloss = len(losses)
+                    if nloss == nind:
+                        pl = list(p)
                     else:
-                        n = len(losses)
                         cw, alfa, beta = lc.fitsteinmetz(
-                            f, B[:n], losses, Bo, fo)
+                            f, B[:nloss], losses, Bo, fo)
                         pl = losses + [lc.pfe_steinmetz(
                             f, b, cw, alfa, beta,
                             self.losses['fo'],
                             self.losses['Bo'])
-                                       for b in B[n:]]
+                                       for b in B[nloss:]]
                     logger.debug("%s", pl)
                     self.writeBlock(pl +
                                     [0.0]*(M_LOSS_INDUCT - len(pl)))
                     self.writeBlock(float(f))
-            for m in range(M_LOSS_FREQ - len(pfe)):
+                    nrec += 1
+            for m in range(M_LOSS_FREQ - nrec):
                 self.writeBlock([0.0]*M_LOSS_INDUCT)
                 self.writeBlock(0.0)
 
@@ -663,21 +690,21 @@ class Writer(Mcv):
         except Exception as e:
             logger.error("Exception %s", e, exc_info=True)
 
-    def writeMcv(self, filename, fillfac=None, recsin=''):
+    def writeMcv(self, filename, fillfac=None, recsin='', feloss='Jordan'):
         # windows needs this strip to remove '\r'
-        filename = filename.strip()
-        self.name = os.path.splitext(filename)[0]
+        filename = pathlib.Path(filename)
+        self.name = filename.stem
 
-        if filename.upper().endswith('.MCV') or \
-           filename.upper().endswith('.MC'):
+        if filename.suffix.upper() in ('.MCV', '.MC'):
             binary = True
-            self.fp = open(filename, "wb")
+            self.fp = filename.open(mode="wb")
         else:
             binary = False
-            self.fp = open(filename, "wb")
-        logger.info("Write File %s, binary format", filename)
+            self.fp = filename.open(mode="w")
+        logger.info("Write File %s, binary format (feloss '%s')",
+                    filename, feloss)
 
-        self.writeBinaryFile(fillfac, recsin)
+        self.writeBinaryFile(fillfac, recsin, feloss)
         self.fp.close()
 
 
@@ -738,17 +765,16 @@ class Reader(Mcv):
 
     def readMcv(self, filename):
         # intens bug : windows needs this strip to remove '\r'
-        filename = filename.strip()
+        filename = pathlib.Path(filename)
 
-        if filename.upper().endswith('.MCV') or \
-           filename.upper().endswith('.MC'):
+        if filename.suffix in ('.MCV', '.MC'):
             binary = True
-            self.fp = open(filename, "rb")
+            self.fp = filename.open(mode="rb")
         else:
             binary = False
-            self.fp = open(filename, "r")
+            self.fp = filename.open(mode="r")
 
-        self.name = os.path.splitext(os.path.basename(filename))[0]
+        self.name = filename.stem
         # read curve version (INTEGER)
         if binary:
             self.version_mc_curve = self.readBlock(int)
@@ -904,6 +930,8 @@ class Reader(Mcv):
         if self.MC1_INDUCTION_FACTOR > 2.0:
             self.MC1_INDUCTION_FACTOR = 2.0
 
+        # TODO: handle self.mc1_ce_factor, self.mc1_induction_beta_factor
+
         self.losses = {}
         try:
             (nfreq, njind) = self.readBlock([int, int])
@@ -1086,13 +1114,14 @@ class MagnetizingCurve(object):
                                 repls.items(), name)
 
     def writefile(self, name, directory='.',
-                  fillfac=None, recsin=''):
+                  fillfac=None, recsin='', feloss='jordan'):
         """find magnetic curve by name or id and write binary file
         Arguments:
           name: key of mcv dict (name or id)
           directory: destination directory (must be writable)
           fillfac: (float) new fill factor (curves will be recalulated if not None or 0)
           recsin: (str) either 'flux' or 'cur' recalculates for eddy current calculation (dynamic simulation)
+          feloss: (str) iron loss calc method ('jordan', 'bertotti', 'steinmetz')
 
         returns filename if found else None
         """
@@ -1126,7 +1155,7 @@ class MagnetizingCurve(object):
         filename = ''.join((bname, ext))
         writer = Writer(mcv)
         writer.writeMcv(os.path.join(directory, filename),
-                        fillfac=fillfac, recsin=recsin)
+                        fillfac=fillfac, recsin=recsin, feloss=feloss)
         return filename
 
     def fitLossCoeffs(self):

femagtools/model.py

@@ -136,14 +136,15 @@ class MachineModel(Model):
         name = 'DRAFT'
         if isinstance(parameters, str):
             name = parameters
+            self.connect_full = False  # no matter
         else:
             if 'name' in parameters:
                 name = parameters['name']
             if 'windings' in parameters:
                 self.winding = self.windings
 
-        # connect model even for complete model (see fsl connect_models)
-        self.connect_full = True
+            # connect model even for complete model (see fsl connect_models)
+            self.connect_full = parameters.get('afmtype', '') == ''
         # must sanitize name to prevent femag complaints
         self.name = ''.join([n
                              for n in name.strip()
@@ -410,7 +411,7 @@ class MachineModel(Model):
             missing += m
             names += n
         if missing:
-            raise MCerror("MC pars missing: {}".format(
+            raise MCerror("Material properties missing: {}".format(
                 ', '.join(set(missing))))
         return set(names)
 

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(
@@ -325,7 +331,7 @@ class ParameterStudy(object):
                                 shutil.copy(ff, repdir)
                         calcid += 1
                     if isinstance(r, dict) and 'error' in r:
-                        logger.warn("job %d failed: %s", k, r['error'])
+                        logger.warning("job %d failed: %s", k, r['error'])
                         if objective_vars:
                             f.append([float('nan')]*len(objective_vars))
                         else:

femagtools/plot/nc.py

@@ -14,7 +14,7 @@ DEFAULT_CMAP='viridis'
 """default colormap (see https://matplotlib.org/stable/users/explain/colors/colormaps.html)"""
 
 
-def spel(isa, superelements=[], with_axis=False, ax=0):
+def spel(isa, superelements=[], with_axis=False, with_wiredir=False, ax=0):
     """plot super elements of I7/ISA7 model
     Args:
       isa: Isa7 object
@@ -35,7 +35,7 @@ def spel(isa, superelements=[], with_axis=False, ax=0):
                             color=isa.color[se.color], lw=0))
         try:
             # draw wire direction
-            if se.subregion:
+            if se.subregion and with_wiredir:
                 if se.subregion.curdir != 0:
                         wkey = se.subregion.winding.key
                         if se.subregion.curdir < 0:

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']}