femagtools 1.8.5__py3-none-any.whl → 1.8.6__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.5'
+__version__ = '1.8.6'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2024 Gamma Technology'

femagtools/bch.py

@@ -618,8 +618,8 @@ class Reader:
 
     def __read_peak_winding_currents(self, content):
         self.scData['peakWindingCurrents'] = [float(x)
-                                              for x in re.findall(r'[-0-9.]+',
-                                                                  ''.join(content))]
+                                              for x in self._numPattern.findall(
+                                                      ''.join(content))]
 
     def __read_general_machine_data(self, content):
         mcfiles = []
@@ -1771,6 +1771,9 @@ class Reader:
     def __getattr__(self, k):
         return self.__dict__[k]
 
+    def asdict(self):
+        return {k[0]: k[1] for k in self.items()}
+
     def items(self):
         return [(k, self.get(k)) for k in ('version',
                                            'type',

femagtools/dxfsl/area.py

@@ -435,6 +435,9 @@ class Area(object):
             self.type == TYPE_WINDINGS or \
             self.type == TYPE_FD_WINDINGS
 
+    def is_field_winding(self):
+        return self.type == TYPE_FD_WINDINGS
+
     def is_magnet(self):
         return self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT
 

femagtools/dxfsl/conv.py

@@ -180,12 +180,6 @@ def main():
                            help='create full model (fsl only)',
                            dest='full_model',
                            action="store_true")
-    argparser.add_argument('--no_processing',
-                           help=(argparse.SUPPRESS if not super_help else
-                                 "omit multiprocessing"),
-                           dest='no_processing',
-                           action="store_true",
-                           default=False)
 
     args = argparser.parse_args()
 
@@ -282,8 +276,7 @@ def main():
                   write_id=args.write_id,
                   debug_mode=args.debugger,
                   full_model=args.full_model,
-                  write_journal=args.journal,
-                  no_processing=args.no_processing)
+                  write_journal=args.journal)
     keys = ('tot_num_slot', 'num_sl_gen', 'num_poles', 'nodedist',
             'dy1', 'da1', 'da2', 'dy2', 'agndst', 'name')
     logger.info("%s", {k: res[k] for k in keys if k in res})

femagtools/dxfsl/converter.py

@@ -10,7 +10,7 @@ from femagtools.dxfsl.shape import Shape
 from femagtools.dxfsl.fslrenderer import FslRenderer, agndst
 from femagtools.dxfsl.plotrenderer import PlotRenderer
 from femagtools.dxfsl.concat import Concatenation
-from femagtools.dxfsl.functions import Timer, SimpleProcess, middle_angle
+from femagtools.dxfsl.functions import Timer, middle_angle
 from femagtools.dxfsl.journal import Journal, getJournal
 from femagtools.dxfsl.area import TYPE_WINDINGS
 from femagtools.dxfsl.areabuilder import disable_logging, enable_logging
@@ -18,7 +18,6 @@ import logging
 import logging.config
 import numpy as np
 import sys
-import multiprocessing
 
 logger = logging.getLogger(__name__)
 
@@ -43,117 +42,6 @@ def plot_geom(doit, plt, geom, title="Plot", areas=True):
                         fill_areas=areas)
 
 
-class SymSearchProcess(SimpleProcess):
-    def __init__(self,
-                 name=None,
-                 queue=None,
-                 machine=None,
-                 plt=None,  # plotter
-                 kind="",
-                 mindist=0.01,
-                 symtol=0.0,
-                 sympart=0,
-                 is_inner=False,
-                 is_outer=False,
-                 show_plots=True,
-                 debug_mode=False,
-                 rows=1,
-                 cols=1,
-                 num=1,
-                 no_processing=False):
-        SimpleProcess.__init__(self,
-                               name=name,
-                               no_processing=no_processing)
-        self.queue = queue
-        self.mach_in = machine
-        self.mach_out = None
-        self.plt = plt
-        self.kind = kind
-        self.mindist = mindist
-        self.symtol = symtol
-        self.sympart = sympart
-        self.is_inner = is_inner
-        self.is_outer = is_outer
-        self.show_plots = show_plots
-        self.debug_mode = debug_mode
-        self.rows = rows
-        self.cols = cols
-        self.num = num
-        pass
-
-    def run(self):
-        if not self.without_processing():
-            logger.info("Process is running")
-            self.plt = None
-            self.show_plots = False
-        else:
-            logger.info("without multiprocessing")
-
-        try:
-            self.mach_out = symmetry_search(
-                self.mach_in,
-                plt=self.plt,
-                kind=self.kind,
-                mindist=self.mindist,
-                symtol=self.symtol,
-                sympart=self.sympart,
-                is_inner=self.is_inner,
-                is_outer=self.is_outer,
-                show_plots=self.show_plots,
-                debug_mode=self.debug_mode,
-                rows=self.rows,
-                cols=self.cols,
-                num=self.num)
-        except Exception as e:
-            logger.warning("Exception in symmetry_search: %s", e)
-        if not self.mach_out:
-            logger.error("NO MACHINE AFTER PROCESS")
-        self.queue.put(self.mach_out)
-        if not self.without_processing():
-            logger.info("Process is finished")
-
-
-class BuildInnerProcess(SimpleProcess):
-    def __init__(self,
-                 name=None,
-                 queue=None,
-                 machine=None,
-                 mindist=0.01,
-                 plt=None,  # plotter
-                 EESM=False,
-                 no_processing=False):
-        SimpleProcess.__init__(self,
-                               name=name,
-                               no_processing=no_processing)
-        self.queue = queue
-        self.mach_in = machine
-        self.mach_out = None
-        self.plt = plt
-        self.mindist = mindist
-        self.EESM = EESM
-        pass
-
-    def run(self):
-        if not self.without_processing():
-            logger.info("Process is running")
-            self.plt = None
-        else:
-            logger.info("without multiprocessing")
-
-        try:
-            self.mach_out = build_inner_machine(
-                self.mach_in,
-                mindist=self.mindist,
-                plt=self.plt,
-                EESM=self.EESM)
-        except Exception as e:
-            logger.warning("Exception in symmetry_search: %s", e)
-
-        self.queue.put(self.mach_out)
-        if not self.without_processing():
-            logger.info("Process is finished")
-
-
 def symmetry_search(machine,
                     plt=None,  # plotter
                     kind="single",
@@ -348,6 +236,7 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
               title="Final Rotor")
 
     t = timer.stop("-- rotor created in %0.4f seconds --")
+    journal.put('time_rotor_created', t)
 
     logger.debug("End of build_machine_rotor")
     return machine_temp
@@ -420,6 +309,7 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
               title="Final Stator")
 
     t = timer.stop("-- stator created in %0.4f seconds --")
+    journal.put('time_stator_created', t)
 
     logger.debug("End of build_machine_stator")
     return machine_temp
@@ -504,8 +394,7 @@ def convert(dxfile,
             write_id=False,
             full_model=False,
             debug_mode=False,
-            write_journal=False,
-            no_processing=False):
+            write_journal=False):
     global journal
     layers = ()
     conv = {}
@@ -724,23 +613,19 @@ def convert(dxfile,
                     machine_outer.set_outer()
 
         start_timer.stop("-- first part in %0.4f seconds --", info=True)
+
         process_timer = Timer(start_it=True)
         # inner part
-        inner_queue = multiprocessing.Queue()
-        inner_proc = SymSearchProcess(name="Inner",  # for logger
-                                      queue=inner_queue,
-                                      machine=machine_inner,
-                                      plt=None,  # plot
-                                      kind=inner_name,
-                                      is_inner=True,
-                                      mindist=mindist,
-                                      symtol=symtol,
-                                      show_plots=show_plots,
-                                      rows=3,  # rows
-                                      cols=2,  # columns
-                                      num=3,   # start num
-                                      no_processing=no_processing)
-        inner_proc.start_task()
+        machine_inner = symmetry_search(machine=machine_inner,
+                                        plt=p,  # plot
+                                        kind=inner_name,
+                                        is_inner=True,
+                                        mindist=mindist,
+                                        symtol=symtol,
+                                        show_plots=show_plots,
+                                        rows=3,  # rows
+                                        cols=2,  # columns
+                                        num=3)   # start num
 
         # outer part
         machine_outer = symmetry_search(machine_outer,
@@ -754,29 +639,20 @@ def convert(dxfile,
                                         cols=2,  # columns
                                         num=4)   # start num
 
-        machine_inner = inner_queue.get()
-        inner_proc.wait()
         process_timer.stop("-- symmetry search in %0.4f seconds --", info=True)
 
         machine_inner.sync_with_counterpart(machine_outer)
 
         final_timer = Timer(start_it=True)
-        inner_queue = multiprocessing.Queue()
-        inner_proc = BuildInnerProcess(name="Inner",  # for logger
-                                       queue=inner_queue,
-                                       machine=machine_inner,
-                                       mindist=mindist,
-                                       plt=p,
-                                       EESM=EESM,
-                                       no_processing=no_processing)
-        inner_proc.start_task()
+        machine_inner = build_inner_machine(machine_inner,
+                                            mindist=mindist,
+                                            plt=p,
+                                            EESM=EESM)
 
         machine_outer = build_outer_machine(machine_outer,
                                             mindist,
                                             p,
                                             EESM=EESM)
-        machine_inner = inner_queue.get()
-        inner_proc.wait()
         final_timer.stop("-- final part in %0.4f seconds --", info=True)
 
         machine_inner.sync_with_counterpart(machine_outer)
@@ -958,7 +834,7 @@ def convert(dxfile,
                 r_out = 0.0
                 r_in = 0.0
             if machine.cut_is_possible(r_in, r_out):
-                logger.info("make a cut")
+                logger.debug("make a cut")
                 machine = machine.cut(r_in, r_out)
 
         if part:
@@ -1080,6 +956,37 @@ def convert(dxfile,
     return conv
 
 
+def _create_rotor_parameters(machine):
+    rotor = {
+        'min_radius': machine.geom.min_radius,
+        'max_radius': machine.geom.max_radius,
+        'mags': machine.geom.magnets_minmax_list(),
+        'fd_wnds': machine.geom.fd_windings_minmax_list()
+    }
+    shaft_min, shaft_max = machine.geom.shaft_minmax()
+    if shaft_max > 0.0:
+        rotor['shaft_min'] = shaft_min
+        rotor['shaft_max'] = shaft_max
+    if shaft_max > rotor['min_radius']:
+        rotor['min_radius'] = shaft_max
+    return rotor
+
+
+def _create_stator_parameters(machine):
+    stator = {
+        'min_radius': machine.geom.min_radius,
+        'max_radius': machine.geom.max_radius,
+        'wnds': machine.geom.windings_minmax_list()
+    }
+    shaft_min, shaft_max = machine.geom.shaft_minmax()
+    if shaft_max > 0.0:
+        stator['shaft_min'] = shaft_min
+        stator['shaft_max'] = shaft_max
+    if shaft_max > stator['min_radius']:
+        stator['min_radius'] = shaft_max
+    return stator
+
+
 def create_femag_parameters(m_inner, m_outer, nodedist=1):
     if not (m_inner and m_outer):
         logger.warning("inner %s outer %s", m_inner, m_outer)
@@ -1122,6 +1029,13 @@ def create_femag_parameters(m_inner, m_outer, nodedist=1):
     params['alfa_slot'] = alfa_slot
     params['alfa_pole'] = alfa_pole
 
+    if m_inner.geom.is_rotor():
+        params['rotor'] = _create_rotor_parameters(m_inner)
+        params['stator'] = _create_stator_parameters(m_outer)
+    else:
+        params['rotor'] = _create_rotor_parameters(m_outer)
+        params['stator'] = _create_stator_parameters(m_inner)
+
     if num_slots == 0 or num_poles == 0:
         if num_slots == 0:
             logger.warning("No slots found")
@@ -1149,6 +1063,8 @@ def create_femag_parameters_stator(motor, position):
         params['dy1'] = 2*motor.geom.max_radius
         params['da1'] = 2*motor.geom.min_radius
     params['slot_area'] = motor.slot_area()
+    params['stator'] = _create_stator_parameters(motor)
+    params['machine'] = motor
     return params
 
 
@@ -1163,4 +1079,6 @@ def create_femag_parameters_rotor(motor, position):
         params['dy1'] = 2*motor.geom.max_radius
         params['da1'] = 2*motor.geom.min_radius
     params['slot_area'] = motor.slot_area()
+    params['rotor'] = _create_rotor_parameters(motor)
+    params['machine'] = motor
     return params

femagtools/dxfsl/geom.py

@@ -4528,6 +4528,55 @@ class Geometry(object):
                 add_element(e)
         self.area_list += area_list
 
+    def areas_minmax_list(self, area_list):
+        if not area_list:
+            return []
+
+        dist_list = []
+        for n, a in enumerate(area_list):
+            dist_list.append((a.min_dist, a.max_dist, n))
+        dist_list.sort()
+
+        minmax_list = []
+        d1_this, d2_this, n = dist_list [0]
+        for d1_next, d2_next, n in dist_list[1:]:
+            if d1_next > d2_this:
+                minmax_list.append((d1_this, d2_this))
+                d1_this = d1_next
+                d2_this = d2_next
+            else:
+                d2_this = max(d2_this, d2_next)
+        minmax_list.append((d1_this, d2_this))
+        return minmax_list
+
+    def magnets_minmax_list(self):
+        magnets = [a for a in self.list_of_areas()
+                   if a.is_magnet()]
+        return self.areas_minmax_list(magnets)
+
+    def windings_minmax_list(self):
+        windings = [a for a in self.list_of_areas()
+                    if a.is_winding()]
+        return self.areas_minmax_list(windings)
+
+    def fd_windings_minmax_list(self):
+        windings = [a for a in self.list_of_areas()
+                    if a.is_field_winding()]
+        return self.areas_minmax_list(windings)
+
+    def shaft_minmax(self):
+        shafts = [a for a in self.list_of_areas()
+                  if a.is_shaft()]
+        if not shafts:
+            return (0.0, 0.0)
+
+        dmin = shafts[0].min_dist
+        dmax = shafts[0].max_dist
+        for s in shafts[1:]:
+            dmin = min(dmin, s.min_dist)
+            dmax = max(dmax, s.max_dist)
+        return (dmin, dmax)
+
     def check_airgap_connecting_nodes(self, geom, startangle, endangle):
         logger.info("check_airgap_connecting_nodes")
 

femagtools/femag.py

@@ -802,8 +802,10 @@ class ZmqFemag(BaseFemag):
         """attaches a notify function"""
         logger.info("Subscribe on '%s' port %d", self.femaghost, self.port+1)
         if self.subscriber is None:
+            # progress/xyplot at a configured timestep published
+            header = [b'progress', b'xyplot', b'license']
             self.subscriber = femagtools.zmq.SubscriberTask(
-                port=self.port+1, host=self.femaghost, notify=notify)
+                port=self.port+1, host=self.femaghost, notify=notify, header=header)
             self.subscriber.start()
         else:
             # reattach?
@@ -1087,7 +1089,7 @@ class ZmqFemag(BaseFemag):
         response = self.send_request(
             ['CONTROL', f'getfile = {filename}'], timeout=1000)
         return [response[0].decode('latin1'),
-                response[1] if len(response) else b'']
+                response[1] if len(response) > 1 else b'']
 
     def exportsvg(self, fslcmds, timeout=10000):
         """get svg format from fsl commands (if any graphic created)
@@ -1156,6 +1158,7 @@ class ZmqFemag(BaseFemag):
         logger.info("Interrupt %s", self.femaghost)
         ctrl.send_string('interrupt')
         ctrl.close()
+        femagtools.zmq.SubscriberTask.clear()
 
     def copy_winding_file(self, name, wdg):
         wdg.write(name, self.workdir)

femagtools/machine/afpm.py

@@ -15,6 +15,7 @@ from scipy.interpolate import make_interp_spline, RegularGridInterpolator, RectB
 from scipy.integrate import quad
 import copy
 from matplotlib.colors import to_rgb
+from multiprocessing import Pool
 
 logger = logging.getLogger(__name__)
 
@@ -54,7 +55,8 @@ def _integrate(radius, pos, val):
     interp = RegularGridInterpolator((radius, pos), val)
     def func(x, y):
         return interp((x, y))
-    return [quad(func, radius[0], radius[-1], args=(p,))[0]
+    return [quad(func, radius[0], radius[-1],
+                  args=(p,), limit=200)[0]
             for p in pos]
 
 
@@ -62,7 +64,7 @@ def _integrate1d(radius, val):
     interp = make_interp_spline(radius, val, k=1)
     def func(x):
         return interp((x))
-    return quad(func, radius[0], radius[-1])[0]
+    return quad(func, radius[0], radius[-1], limit=100)[0]
 
 def ld_interpol(i1, beta, v):
     '''interpolate Ld at beta angle 0°, -180°'''
@@ -152,7 +154,17 @@ def parident(workdir, engine, temp, machine,
         machine[wdgk].get('num_par_wdgs', 1))
 
     p = machine['poles']
-    num_slices = kwargs.get('num_slices', 3)
+    if np.isscalar(machine['magnet']['afm_rotor']['rel_magn_width']):
+        num_slices = kwargs.get('num_slices', 3)
+        rmagw = num_slices*[machine['magnet']['afm_rotor']['rel_magn_width']]
+    else:
+        rmagw = machine['magnet']['afm_rotor']['rel_magn_width']
+        if len(rmagw) == 1:
+            num_slices = kwargs.get('num_slices', 3)
+            rmagw = num_slices*list(rmagw)
+        else:
+            num_slices = len(rmagw)
+
     lfe = get_arm_lengths(machine['outer_diam'],
                           machine['inner_diam'],
                           num_slices)
@@ -172,6 +184,8 @@ def parident(workdir, engine, temp, machine,
         "decision_vars": [
             {"values": pole_width,
              "name": "pole_width"},
+            {"values": rmagw,
+             "name": "magnet.afm_rotor.rel_magn_width"},
             {"values": lfe,
              "name": "lfe"},
             {"values": linspeed, "name": "speed"}
@@ -216,9 +230,11 @@ def parident(workdir, engine, temp, machine,
         else:
             nlresults = {"x": [], "f": []}
             i = 0
-            for pw, le, sp in zip(pole_width, lfe, linspeed):
+
+            for pw, le, sp, rmw in zip(pole_width, lfe, linspeed, rmagw):
                 nlmachine = {k: machine[k] for k in machine}
                 nlmachine['pole_width'] = pw
+                nlmachine['magnet']['afm_rotor']['rel_magn_width'] = rmw
                 nlmachine['lfe'] = le
                 nlcalc.update({"speed": sp})
                 nlsubdir = f'{workdir}/{i}'
@@ -237,10 +253,11 @@ def parident(workdir, engine, temp, machine,
         current_angles = nlresults['f'][0]['current_angles']
         results = []
         i = 0
-        for l, pw in zip(lfe, pole_width):
+        for l, pw, rmw in zip(lfe, pole_width, rmagw):
             mpart = {k: machine[k] for k in machine if k != 'afm_rotor'}
             mpart['pole_width'] = pw
             mpart['lfe'] = l
+            mpart['magnet']['afm_rotor']['rel_magn_width'] = rmw
             subdir = f"{workdir}/{i}"
 
             simulation = dict(
@@ -296,12 +313,23 @@ def parident(workdir, engine, temp, machine,
             i += 1
 
         postp = []
-        for results in [process(lfe, pole_width, machine, bch)
-                        for bch in zip(*[r['f'] for r in results])]:
-            torque = np.mean(results.pop('torque'))
-            results['torque'] = torque
-            results.update(_psidq_ldq(results, nlresults))
-            postp.append(results)
+        if kwargs.get('use_multiprocessing', True):
+            with Pool() as p:
+                for r in p.starmap(process,
+                                   [(lfe, pole_width, machine, bch)
+                                    for bch in zip(*[r['f']
+                                                     for r in results])]):
+                    torque = np.mean(r.pop('torque'))
+                    r['torque'] = torque
+                    r.update(_psidq_ldq(r, nlresults))
+                    postp.append(r)
+        else:
+            for r in [process(lfe, pole_width, machine, bch)
+                      for bch in zip(*[r['f'] for r in results])]:
+                torque = np.mean(r.pop('torque'))
+                r['torque'] = torque
+                r.update(_psidq_ldq(r, nlresults))
+                postp.append(r)
 
         r1 = postp[0]['r1']
         i1 = [r['i1'] for r in postp][::num_beta_steps]
@@ -396,6 +424,7 @@ def process(lfe, pole_width, machine, bch):
     n = len(rotpos[0])
     currents = [bch[0]['flux'][k][0]['current_k'][:n]
                 for k in bch[0]['flux']]
+
     if len(pole_width) > 1:
         # check homogenity:
         if np.diff([len(d) for d in displ]).any():
@@ -427,6 +456,9 @@ def process(lfe, pole_width, machine, bch):
                        for ux in bch[0]['flux'][k][0]['voltage_dpsi'][:-1]]
                    for k in bch[0]['flux']}
         emf = [voltage[k][:n] for k in voltage]
+        fluxxy = {k: [scale_factor * np.array(flx)
+                      for flx in bch[0]['flux'][k][0]['flux_k']]
+                  for k in bch[0]['flux']}
         flux = [fluxxy[k][:n] for k in fluxxy]
 
     pos = (rotpos[0]/np.pi*180)
@@ -485,7 +517,6 @@ def process(lfe, pole_width, machine, bch):
     except KeyError as exc:
         #logger.warning("missing key %s", exc)
         pass
-
     return {
         'weights': weights.tolist(),
         'pos': pos.tolist(), 'r1': r1,
@@ -646,13 +677,20 @@ def _draw_vertical_slots(ax,
     color = _get_colors(color, delta)
     taus = 2*np.pi/Q
     for n in range(Q):
-        beta = np.array([[n*taus+alpha[0], (n+1)*taus-alpha[0]],
-                         [(n+1)*taus-alpha[1], n*taus+alpha[1]]])
-        ax.fill(np.hstack((r * np.cos(beta[0, 0]),
-                           (r[::-1] * np.cos(beta[0, 1]))))+xoff,
-                np.hstack((r * np.sin(beta[0, 0]),
-                           (r[::-1] * np.sin(beta[0, 1]))))+yoff,
-                facecolor=color[0], edgecolor=color[0])
+        beta0 = np.linspace(n*taus, n*taus + taus/2-alpha[0], 5)
+        beta1 = np.linspace(n*taus, n*taus + taus/2-alpha[1], 5)
+        xr = np.concatenate((
+            r[0]*np.cos(beta0), r[1]*np.cos(beta1[::-1])))+xoff
+        yr = np.concatenate((
+            r[0]*np.sin(beta0), r[1]*np.sin(beta1[::-1])))+yoff
+        ax.fill(xr, yr, color=color[0])
+        beta0 = np.linspace(n*taus + taus/2+alpha[0], (n+1)*taus, 5)
+        beta1 = np.linspace(n*taus + taus/2+alpha[1], (n+1)*taus, 5)
+        xr = np.concatenate((
+            r[0]*np.cos(beta0), r[1]*np.cos(beta1[::-1])))
+        yr = np.concatenate((
+            r[0]*np.sin(beta0), r[1]*np.sin(beta1[::-1])))
+        ax.fill(xr, yr, color=color[0])
 
 
 def vertical_plot(machine, ax):
@@ -669,7 +707,7 @@ def vertical_plot(machine, ax):
     model_type = machine['afmtype'][0:4]
     dy1 = machine['outer_diam']*1e3
     dy2 = machine['inner_diam']*1e3
-    rel_magn_width = machine['magnet']['afm_rotor']['rel_magn_width']
+    rel_magn_width = max(machine['magnet']['afm_rotor']['rel_magn_width'])
     Q = machine['stator']['num_slots']
     slot_width = machine['stator']['afm_stator']['slot_width']*1e3
     poles = machine['poles']
@@ -818,7 +856,7 @@ def horizontal_plot(machine, ax):
     model_type = machine['afmtype'][0:4]
     dy1 = machine['outer_diam']*1e3
     dy2 = machine['inner_diam']*1e3
-    rel_magn_width = machine['magnet']['afm_rotor']['rel_magn_width']
+    rel_magn_width = max(machine['magnet']['afm_rotor']['rel_magn_width'])
     magn_height = machine['magnet']['afm_rotor']['magn_height']*1e3
     magn_yoke_height = machine['magnet']['afm_rotor']['yoke_height']*1e3
 
@@ -911,6 +949,14 @@ class AFPM:
         except KeyError:
             raise ValueError("missing key afmtype")
 
+        if np.isscalar(machine['magnet']['afm_rotor']['rel_magn_width']):
+            rmagw = num_slices*[machine['magnet']['afm_rotor']['rel_magn_width']]
+        else:
+            rmagw = machine['magnet']['afm_rotor']['rel_magn_width']
+            if len(rmagw) == 1:
+                rmagw = num_slices*list(rmagw)
+            elif num_slices != len(rmagw):
+                num_slices = len(rmagw)
         lfe = get_arm_lengths(machine['outer_diam'],
                               machine['inner_diam'],
                               num_slices)
@@ -934,11 +980,17 @@ class AFPM:
                  "name": "pole_width"},
                 {"values": lfe,
                  "name": "lfe"},
+                {"values": rmagw,
+                 "name": "magnet.afm_rotor.rel_magn_width"},
                 {"values": linspeed, "name": "speed"}
             ]
         }
+
         machine['pole_width'] = np.pi * machine['inner_diam']/machine['poles']
         machine['lfe'] = machine['outer_diam'] - machine['inner_diam']
+        machine['magnet']['afm_rotor']['rel_magn_width'] = max(
+            machine['magnet']['afm_rotor']['rel_magn_width'])
+
         simulation['skew_displ'] = (simulation.get('skew_angle', 0)/180 * np.pi
                                     * machine['inner_diam'])
         nlresults = {}

femagtools/multiproc.py

@@ -56,7 +56,8 @@ class ProgressLogger(threading.Thread):
                         ["progress_logger",
                          f"{self.numTot}:{numOf}:{percent}:{' '.join(summary)}"])
             else:
-                logger.info('collecting FE losses ...')
+                # TODO: log message might be misleading
+                logger.debug('collecting FE losses ...')
                 return
 
     def stop(self):

femagtools/plot/__init__.py

@@ -1,6 +1,7 @@
 """Creating plots
 
 """
+from .machine import machine
 from .fluxdens import airgap, airgap_fft
 from .bch import torque, torque_fft, force, force_fft, \
     fluxdens_surface, winding_current, winding_flux, \

femagtools/plot/bch.py

@@ -22,6 +22,26 @@ except ImportError:   # ModuleNotFoundError:
 logger = logging.getLogger("femagtools.plot.bch")
 
 
+def find_peaks_and_valleys(t, y):
+    """ return peaks and valleys of y with maximum amplitude
+    """
+    peaks = (np.diff(np.sign(np.diff(y))) < 0).nonzero()[0] + 1
+    if len(peaks > 0):
+        ip = np.argmax(y[peaks])
+        pv = {'yp': y[peaks][ip], 'tp': t[peaks][ip]}
+    else:
+        pv = {'yp': [], 'tp': []}
+    valleys = (np.diff(np.sign(np.diff(y))) > 0).nonzero()[0] + 1
+    if len(valleys > 0):
+        iv = np.argmin(y[valleys])
+        pv.update({'yv': y[valleys][iv], 'tv': t[valleys][iv]})
+    else:
+        pv.update({'yv': [], 'tv': []})
+    pv.update({'peaks': y[peaks], 'valleys': y[valleys],
+               'tpeaks': t[peaks], 'tvalleys': t[valleys]})
+    return pv
+
+
 def _create_3d_axis():
     """creates a subplot with 3d projection if one does not already exist"""
     from matplotlib.projections import get_projection_class
@@ -511,30 +531,62 @@ def transientsc(bch, title=''):
     ax.grid(True)
     istat = np.array([bch.scData[i]
                       for i in ('ia', 'ib', 'ic')])
+    pv = [find_peaks_and_valleys(
+        np.array(bch.scData['time']), i1)
+          for i1 in istat]
+    try:
+        ipvmax = np.argmax(
+            [y['yp'] if np.abs(y['yp']) > np.abs(y['yv']) else y['yv']
+             for y in pv])
+        imax = pv[ipvmax]['yp'] if np.abs(pv[ipvmax]['yp']) > np.abs(pv[ipvmax]['yv']) else pv[ipvmax]['yv']
+    except KeyError:
+        pass
     if np.max(istat) > 4000:
         istat *= 1e-3
+        imax *= 1e-3
         ax.set_title('Currents / kA')
     else:
         ax.set_title('Currents / A')
 
     for i, iph in zip(('ia', 'ib', 'ic'), istat):
         ax.plot(bch.scData['time'], iph, label=i)
+    try:
+        ax.plot([pv[ipvmax]['tp']], [imax], '.')
+        ax.annotate(f'Imax = {imax:.1f}',
+                    xy=(pv[ipvmax]['tp'], imax),
+                    xytext=(pv[ipvmax]['tp']+0.01, imax))
+    except NameError:
+        pass
     ax.set_xlabel('Time / s')
     ax.legend()
 
     row = 2
     plt.subplot(rows, cols, row)
     ax = plt.gca()
-    scale = 1
+    pv = find_peaks_and_valleys(
+        np.array(bch.scData['time']), np.array(bch.scData['torque']))
+    try:
+        tqmax = pv['yp'] if np.abs(pv['yp']) > np.abs(pv['yv']) else pv['yv']
+        tp = pv['tp'] if np.abs(pv['yp']) > np.abs(pv['yv']) else pv['tv']
+    except KeyError:
+        pass
     torque = np.array(bch.scData['torque'])
     if np.max(torque) > 4000:
         torque *= 1e-3
+        tqmax *= 1e-3
         ax.set_title('Torque / kNm')
     else:
         ax.set_title('Torque / Nm')
 
     ax.grid(True)
     ax.plot(bch.scData['time'], torque)
+    try:
+        ax.plot([tp], [tqmax], '.')
+        ax.annotate(f'Tmax = {tqmax:.1f}',
+                    xy=(tp, tqmax),
+                    xytext=(tp+0.01, tqmax))
+    except NameError:
+        pass
     ax.set_xlabel('Time / s')
 
     fig.tight_layout(h_pad=2)
@@ -560,8 +612,10 @@ def transientsc_demag(demag, magnet=0, title='', ax=0):
             label='H Max {:4.2f} kA/m'.format(max(hmax)))
     ax.plot(pos, havg,
             label='H Avg {:4.2f} kA/m'.format(max(havg)))
-    ax.plot([pos[0], pos[-1]], hclim, color='C3', linestyle='dashed',
-            label='Hc {:4.2f} kA/m'.format(hclim[0]))
+    if len(hclim) > 1:
+        ax.plot([pos[0], pos[-1]], hclim, color='C3', linestyle='dashed',
+                label='Hc {:4.2f} kA/m'.format(hclim[0]))
+
     ax.set_xlabel('Rotor Position / °')
     ax.grid(True)
     if magnet:

femagtools/plot/machine.py

@@ -0,0 +1,100 @@
+"""
+Create longitudinal drawing of radial flux machine
+"""
+import matplotlib.pyplot as plt
+import matplotlib.patches as pch
+
+def _draw_shaft(ax, dy2, lfe):
+    xx = (0.0, lfe, lfe, 0.0)
+    yy = (dy2/2, dy2/2, -dy2/2, -dy2/2)
+    ax.fill(xx, yy,
+            facecolor='lightgrey',
+            edgecolor='black',
+            linewidth=0)
+    xx = (-lfe/4, lfe+lfe/4, lfe+lfe/4, -lfe/4)
+    yy = (dy2/4, dy2/4, -dy2/4, -dy2/4)
+    ax.fill(xx, yy,
+            facecolor='lightgrey',
+            edgecolor='black',
+            linewidth=0)
+
+def _draw_rotor(ax, da1, dy2, lfe):
+    ag = 0.02*da1
+    xx = (0.0, lfe, lfe, 0.0)
+    yy = (dy2/2, dy2/2, da1/2-ag, da1/2-ag)
+    ax.fill(xx, yy,
+            facecolor='skyblue',
+            edgecolor='black',
+            linewidth=0)
+    yy = (-dy2/2, -dy2/2, -da1/2+ag, -da1/2+ag)
+    ax.fill(xx, yy,
+            facecolor='skyblue',
+            edgecolor='black',
+            linewidth=0)
+
+def _draw_stator(ax, da1, dy1, lfe):
+    xx = (0.0, lfe, lfe, 0.0)
+    yy = (da1/2, da1/2, dy1/2, dy1/2)
+    # yoke
+    ax.fill(xx, yy,
+            facecolor='skyblue',
+            edgecolor='black',
+            linewidth=0)
+
+    yy = (-da1/2, -da1/2, -dy1/2, -dy1/2)
+    ax.fill(xx, yy,
+            facecolor='skyblue',
+            edgecolor='black',
+            linewidth=0)
+
+    # winding
+    yh = (dy1-da1)/2
+    xx = (-yh/2, 0, 0, -yh/2)
+    yy = (da1/2, da1/2, dy1/2-yh/2, dy1/2-yh/2)
+    ax.fill(xx, yy, facecolor='gold',
+                edgecolor='black',
+                linewidth=0)
+
+    xx = (lfe, lfe+yh/2, lfe+yh/2, lfe)
+    ax.fill(xx, yy, facecolor='gold',
+                edgecolor='black',
+                linewidth=0)
+
+    yy = (-da1/2, -da1/2, -dy1/2+yh/2, -dy1/2+yh/2)
+    ax.fill(xx, yy, facecolor='gold',
+                edgecolor='black',
+                linewidth=0)
+
+    xx = (-yh/2, 0, 0, -yh/2)
+    ax.fill(xx, yy, facecolor='gold',
+                edgecolor='black',
+                linewidth=0)
+
+def machine(machine, ax):
+    dy2 = machine['inner_diam']*1e3
+    dy1 = machine['outer_diam']*1e3
+    da1 = machine['bore_diam']*1e3
+    lfe = machine['lfe']*1e3
+
+    _draw_rotor(ax, da1, dy2, lfe)
+    _draw_stator(ax, da1, dy1, lfe)
+    _draw_shaft(ax, dy2, lfe)
+    ax.set_aspect('equal')
+
+    for loc, spine in ax.spines.items():
+        spine.set_color('none')  # don't draw spine
+    #ax.yaxis.set_ticks([])
+    #ax.xaxis.set_ticks([])
+
+
+if __name__ == '__main__':
+    machine1 = {
+        "outer_diam": 0.2442,
+        "bore_diam": 0.179,
+        "inner_diam": 0.06,
+        "airgap": 0.7e-3,
+        "lfe": 0.083,
+    }
+    fig, ax = plt.subplots()
+    machine(machine1, ax)
+    plt.show()

femagtools/poc.py

@@ -75,6 +75,7 @@ class Poc:
         if self.pole_pitch:
             content.append("{0}".format(self.pole_pitch))
         if self.pocType in ['fun', 'har', 'hsp']:
+            self.data_check()
             func_steps = len(self.func_current)
             content += [f"{self.pocType}", f"{func_steps}"]
             if (self.pocType == 'fun' and
@@ -122,6 +123,7 @@ class Poc:
             import re
             for i in range(func_steps-1):
                 l = re.split(';|\t|,| ', pocfile.readline().strip())
+                l = [i for i in l if i]  # remove empty items
                 if len(l) > 2:
                     self.harmonic_id.append(int(l[0]))
                     self.func_current.append(float(l[1]))
@@ -129,6 +131,7 @@ class Poc:
                 else:
                     self.func_current.append(float(l[0]))
                     self.func_phi.append(float(l[1]))
+            self.data_check()
         else:
             self.shape_current=self.pocType
             self.pocType='Function'
@@ -139,6 +142,13 @@ class Poc:
         except ValueError:
             pass
 
+    def data_check( self ):
+        """simple phi data increasing check"""
+        import numpy as np
+        if (not np.all(np.diff(self.func_phi) > 0)
+            and np.all(np.diff(self.func_current) > 0)):
+            self.func_phi, self.func_current = self.func_current, self.func_phi
+
     def getProps( self ):
         keys=['key_winding',
               'phi_voltage_winding',

femagtools/utils.py

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

femagtools/zmq.py

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

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

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

{femagtools-1.8.5.dist-info → femagtools-1.8.6.dist-info}/RECORD

@@ -1,9 +1,9 @@
-femagtools/__init__.py,sha256=AYG-i1TsOTL54WdFZq9UcxAcqn7kj3GFb6Q_xMGw0jc,1600
+femagtools/__init__.py,sha256=2SMaY7V-Yp8JBGAb9m9bsHhX8WWkzbzADhc7yCeh0Lw,1600
 femagtools/airgap.py,sha256=hELJXe52yUw82JwZ1tGUXUtRhMG2_WSUBVeGkTZSAM8,1900
 femagtools/amazon.py,sha256=O1ICuv21XDAJi1qK1Sigs2TdS6hDZP19OzvmE2t76wU,12069
 femagtools/amela.py,sha256=RFTuQ5EcX19G2YJchnktr6j62mNptrdTreShQDOeuKA,13874
 femagtools/asm.py,sha256=CiL0KWaF4P7O6-VwmGLdva_icwmPrPiI-TFQ19XYTKk,7660
-femagtools/bch.py,sha256=7-Qd8BjxbYjNhmHbZtblsIW3FavjREiSE-RkAHA0TO4,74068
+femagtools/bch.py,sha256=PSQmGp2zuAqMYnE9r-zZdehxVcS8BKtAunpBEZTn9uA,74131
 femagtools/bchxml.py,sha256=KrRjAdrUPZXmiWvonu9HhpG_NvImMBpiXWTL4iSr4kE,3142
 femagtools/condor.py,sha256=J8z9iBdvrGu3I1eFNoyKV8AXzRoTEPGLSak6cXUQxAM,10766
 femagtools/conductor.py,sha256=rXO7c7Qh_s7JpgILmLd4IbG64vP6Eh143YF9u25Mdwg,1076
@@ -15,7 +15,7 @@ femagtools/dakotaout.py,sha256=6nn0PXsB40mPKiQLenqAtHy0KXCO7kvqqQ-aD2JhQvw,5573
 femagtools/docker.py,sha256=XDVmLBB0z4sZZpcrx7Wbm84xl4ksj7aqn5-ZOPxdxm4,7460
 femagtools/ecloss.py,sha256=kTsE9Lx6nt6Ez9PBfD58hPMcnH2PxSc95zJaYMCQd5Q,33957
 femagtools/erg.py,sha256=IXKq76P9qLt_ssNOP78v8Qizk3J2Zg80yaKDSjzwoJE,1224
-femagtools/femag.py,sha256=gku2PP8rEj8UWRUscD5jYB7kKzlA4lcbd-y2sTdRClQ,47291
+femagtools/femag.py,sha256=MDCw2k6MHF69N99turE_5T5qaciKqnREocev6x_6_fU,47479
 femagtools/forcedens.py,sha256=7NNv75Vg9vQ_fy8W4kM2rlSO970zaSmeurhPmdAxsOU,8485
 femagtools/fsl.py,sha256=Bq6bVykmU0Ih5YTbxhRAlCMn2fx1UE2G2UxGI83EKGQ,37072
 femagtools/getset.py,sha256=yJ6Em35DeWK7WNZW0qjjS5s7LUkVh5mbgxF59HHm5FM,3017
@@ -33,35 +33,35 @@ femagtools/mcv.py,sha256=1yXaQIQEC63WmInnt0HggeFKRk2PmrPC90_uGd5-dOw,41696
 femagtools/me.py,sha256=z6RJkvSbgMmorCQTxKvq44uIYKh82uYYExjkNePJCmE,1813
 femagtools/model.py,sha256=dk9x-iqRzgOTdTCeU_ynUZGb1bt4FvU1ZGMPXytMbUg,17965
 femagtools/moproblem.py,sha256=kOP8pRdD8YXz28_M2WKnFgl3eeJ7tqg49ohoazsmUOg,2825
-femagtools/multiproc.py,sha256=p2Y4gu-WlGdN9v6aL4IUHPG0bANHUPSE4a9F64wIMoY,9050
+femagtools/multiproc.py,sha256=Y8nx0W4NgRoG6UWO6TUD1drx216xnzSYuBbisCHhqrY,9107
 femagtools/mxw2msh.py,sha256=CIIqAvfs8U-A0OfuOAoDaqNSmoMSHSI_tW1CPFRCP5E,2151
 femagtools/nc.py,sha256=bAj3iurE9WaovoCi76ry2aJZJ6rC1zO6xWrfsSD6lrc,15160
 femagtools/netlist.py,sha256=CSCl8setLZ_L8DCnNWaNA3-wLe1yo-fmzARZoVvYfaA,2052
 femagtools/ntib.py,sha256=76g1ZO3Fq_kN-HTMBvaKvJmMMlJMyEPFeNAcJPq3w7Y,3099
 femagtools/opt.py,sha256=wBU0yh3hZlNti_zfIvtKcPg1EJrnE3I1BqmVxLGWixU,8753
 femagtools/parstudy.py,sha256=lLz2SIxUJRc1YV54vW-Zl1h_MvP9mHMtl1RJa_ich3c,19734
-femagtools/poc.py,sha256=wMwOxMhPLFRiGPMsKQwWWuGr6UZPzRBajhfVMfXptNU,6794
+femagtools/poc.py,sha256=yPWmpi8Q2g7NmpAi2YV5ezyo0VUj67EK0tcX2wikerw,7207
 femagtools/semi_fea.py,sha256=WZtYKrzhDruETyuEW2kpiNp9OaA7Hheq3qJiAIYtsjg,3475
 femagtools/tks.py,sha256=C3lDdS91Yikf3cMnW-OEqmie-q6S24T81cCFrzwOyeI,7532
 femagtools/ts.py,sha256=x9aCMVASjdBZuyI2pJGMyi1dveGFd_pWQ20cZ-l_moc,47216
-femagtools/utils.py,sha256=IXMk5ZI7B8CPePT523o_9doTKaaWuFe93AVwkBxkp00,1587
+femagtools/utils.py,sha256=dJkQ5xsoVMzSEB5-2hEiwe2of9mLmsDo8nkrnSN-gPE,1643
 femagtools/vbf.py,sha256=9XGfhftmD9carU8ByQ5DwqoR4daq5mJ39eMqruwml0Q,2444
 femagtools/vtu.py,sha256=Sf83dHIfCKY2km-MIUHKKoj-JKN4PDX7kkPLZXyIYY4,10723
 femagtools/windings.py,sha256=RS3QSx1JY0FXzItDuWimC9zYzRxq9n6BbY5fZt1dMFg,23780
-femagtools/zmq.py,sha256=fsPvLbL7UB1CarTgixbWclIlVmCCsU4JLTKGEdg1wcU,8508
+femagtools/zmq.py,sha256=HY8U7dxXkgE48151nvLcnLPa8OFBZcZTrB2XcjBc0Y4,9413
 femagtools/dxfsl/__init__.py,sha256=MywcCdpKPKs4qJBJJgeDsikJFJ2P48dbTuNk303f5pM,76
-femagtools/dxfsl/area.py,sha256=CXLf4lagLGGMkGZLfwowpH50djsZkepYSU5F3Juyxqo,69679
+femagtools/dxfsl/area.py,sha256=CpTMRBF8_AJmJMkkn-LgRv27U5xJ5Ohhd2ppRvESPNU,69757
 femagtools/dxfsl/areabuilder.py,sha256=6dfWryYjXzGIVDOsX2zb1VKIhUzmpL43XhF-wtdesAg,35882
 femagtools/dxfsl/concat.py,sha256=F6scwesxyOmfmKQ5kGspNCxA71Yz6QgxFL7lTj3hsaI,13385
-femagtools/dxfsl/conv.py,sha256=9ki4PGyKuPpsSifKrBPu5_IvbhePv3sQU-Sq8A64s4w,12606
-femagtools/dxfsl/converter.py,sha256=SYz5JWh485EeLA5K4gtz2jsVo8z0CXUjVn5tJ4JoEuM,43453
+femagtools/dxfsl/conv.py,sha256=rAG_r2twWtcZyLKe8L8gYcC-n-JMG-dK1iMmd9yviTQ,12237
+femagtools/dxfsl/converter.py,sha256=PQ92kyRIxKWdrlVpNSvIq_Ska-RDMC26RVM1rluPVk0,40826
 femagtools/dxfsl/corner.py,sha256=-XPBcnEau-2-SRHLYzlBqCQGaFfgm_DH2qR1mSaFoAs,1311
 femagtools/dxfsl/dumprenderer.py,sha256=n4AvInjvGIaC2iKZtQaYXXDyJVSQ3uEOFOLD4-xfKRY,1861
 femagtools/dxfsl/dxfparser.py,sha256=kyXG0kZfNyOgn96MqBgP8RhOQhppfB5NbyRNNybs1C0,13451
 femagtools/dxfsl/femparser.py,sha256=O8940Q1Mz8MKng6W8M3s9KfTvhDLJ56tfQWtZEW3xMM,2134
 femagtools/dxfsl/fslrenderer.py,sha256=gaHBJwqPt7fVz-fyphCb-xppmIFvu72zBpeB18eAvko,27826
 femagtools/dxfsl/functions.py,sha256=1RFT2YPR_rTJSKtTqIoO8Z-s_kXKIp95zed83SM0gZg,12784
-femagtools/dxfsl/geom.py,sha256=rDOgfYYkhwpR8lf30Tr1sTo-j7kZ300XBAX_gEHw79M,176516
+femagtools/dxfsl/geom.py,sha256=bUa_5103OdNJTzEexYYPvMs9Kx1BSNbvWL9ekETWmI4,178082
 femagtools/dxfsl/journal.py,sha256=r4z52av3k95MjwzypgUJpj8sSAeQoJsS81Uqs1IBLVw,4265
 femagtools/dxfsl/machine.py,sha256=_GmGQdrH7yCkRdCCdkm4yALHS1Gwof77zJOZbWtgRPo,57990
 femagtools/dxfsl/plotrenderer.py,sha256=q2cORuxJEf1Ws6oCY9c0gF6N3kDrcI6WOz3u5Vl6R_c,13823
@@ -69,7 +69,7 @@ femagtools/dxfsl/shape.py,sha256=uQqbgXIA2_KP2XRdhCfVfGWjcjwzhJ5t9RhiqR9R98c,616
 femagtools/dxfsl/svgparser.py,sha256=RY2TU9MK6gOaNmI6w6RNqcw7H9YGmK-NUwvdylKBcsE,3763
 femagtools/dxfsl/symmetry.py,sha256=dXfZVIqT49nbMirY5YVaRPi8kNB8reaiq-eIbhw1Z54,43936
 femagtools/machine/__init__.py,sha256=B7yeRZzf29NWCWy8C8iJFdTr9bszAoMRcVEpblhCeg4,7256
-femagtools/machine/afpm.py,sha256=6P84lMVGgpnNcZBNkelTMNmaGGjydan_0loZ_n0K7Zc,35658
+femagtools/machine/afpm.py,sha256=rUByVyzNhT0BEUgTCj-HuU4Wbi4PWVAOeOZfa23Cejk,37980
 femagtools/machine/effloss.py,sha256=gOgVdAr703Vh9T2Ht14of_I-95QOkH5qXmm11bfHK7s,14414
 femagtools/machine/im.py,sha256=isMSoCnIk4Hj47MwBNP5PW7a2rI-7N35A9zHGOSl43s,38111
 femagtools/machine/pm.py,sha256=C4vDdPIsIRUKtzY3b1RNT1v37p1uP3pMUduftNejcPc,68129
@@ -83,12 +83,13 @@ femagtools/moo/problem.py,sha256=McIGKAXK97Jygumns0qmFeYxTG6KDRSQj2aENeC9F9A,239
 femagtools/moo/test/AlgorithmTest.py,sha256=KzR1og4bu6NOE61DDKjEMTQdsysmho4LCYmJ6WZoILo,2535
 femagtools/moo/test/PopulationTest.py,sha256=lG9NeWo0xrslfQRa4tgy1Nj23VJMFIlg_vQ9KUBYnRA,5529
 femagtools/moo/test/ProblemTest.py,sha256=r5XEfY4LPscDb35TxxPd0lbP3nUmL6_G6vrRo1I3RSg,505
-femagtools/plot/__init__.py,sha256=f0yNw9NhadltPIu7zRWwTAY6FgHKeq9ul-3UcnK8Fmk,949
-femagtools/plot/bch.py,sha256=_EEPPEqtEPeWco3xlQqUuZft1eF-IXbMNnXyd8pYEJs,28873
+femagtools/plot/__init__.py,sha256=LFrHy_9L6FxJqhYND2z1534s3ebPXkfXVagFeNA1wWk,978
+femagtools/plot/bch.py,sha256=Sdy6S_XT6bGnl21V-1XscqTkFUCIy-fCX8PivShI9GY,30754
 femagtools/plot/char.py,sha256=xv4cNOTorK-fy7eUFhmyR-013TFI2A2999xXKgL2AnA,12469
 femagtools/plot/fieldlines.py,sha256=_7ykKhnQLeS4fz34pnzovH1gIhcUSKJ3gl1GUgWYix8,1137
 femagtools/plot/fluxdens.py,sha256=NlexRJ3f_8CgKoWrV82ZIsAXPrLhwj98uOe8_fUks7A,1082
 femagtools/plot/forcedens.py,sha256=Vloi9czy7qbGXI-Vm7Cow6IfHTsFhCLI1YWduFOR55c,4075
+femagtools/plot/machine.py,sha256=fVLOZTc19Ru8eXLdtoTeIYsHRWhGLkn_YVZ6qO6KgrE,2654
 femagtools/plot/mcv.py,sha256=ijZg6KPwZC7sDxEzGEUfVWvDoSEfgcaH-hzQMt7E90I,3671
 femagtools/plot/nc.py,sha256=kfTifzAMReQZu4UmbHZo1caAK0n7N51lkPj7BU7l1lU,10876
 femagtools/plot/phasor.py,sha256=5QG1GkXKVksc8P6Q4thKADf6W1l8rDKeArIHFYvbXlw,4858
@@ -215,9 +216,9 @@ tests/moo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/moo/test_algorithm.py,sha256=Em8sFm2vzPmuIzRrBBnUQLU_TYuJHSf-kEeozw0XeX4,2563
 tests/moo/test_population.py,sha256=FvX9LRCxQx0_E2GxHQ5vKwOYFBQiNbT6Lmv5GmNWjTQ,5471
 tests/moo/test_problem.py,sha256=ALeP4u7g-dFhfwWL8vxivdrrYzVKPjHMCAXzzgyNZbs,467
-femagtools-1.8.5.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
-femagtools-1.8.5.dist-info/METADATA,sha256=CxspB9_deq3AqzLvZWTL8kn0ZpMD6yiUKo67ppIZ1y4,6190
-femagtools-1.8.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-femagtools-1.8.5.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
-femagtools-1.8.5.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.8.5.dist-info/RECORD,,
+femagtools-1.8.6.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
+femagtools-1.8.6.dist-info/METADATA,sha256=tI4Q7eHYpIQea6ThRR-t4cUGHGolUaBOwmzxfHktp_E,6190
+femagtools-1.8.6.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+femagtools-1.8.6.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
+femagtools-1.8.6.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
+femagtools-1.8.6.dist-info/RECORD,,