femagtools 1.8.5__tar.gz → 1.8.6__tar.gz

{femagtools-1.8.5/src/femagtools.egg-info → femagtools-1.8.6}/PKG-INFO

@@ -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 → femagtools-1.8.6}/src/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-1.8.5 → femagtools-1.8.6}/src/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-1.8.5 → femagtools-1.8.6}/src/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-1.8.5 → femagtools-1.8.6}/src/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-1.8.5 → femagtools-1.8.6}/src/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-1.8.5 → femagtools-1.8.6}/src/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-1.8.5 → femagtools-1.8.6}/src/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-1.8.5 → femagtools-1.8.6}/src/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 = {}