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

femagtools/femag.py

@@ -27,6 +27,7 @@ import femagtools.fsl
 import femagtools.config
 import femagtools.ecloss
 import femagtools.forcedens
+import femagtools.zmq
 
 from femagtools import ntib
 
@@ -180,15 +181,22 @@ class BaseFemag(object):
     def copy_winding_file(self, name, wdg):
         wdg.write(name, self.workdir)
 
-    def copy_magnetizing_curves(self, model, dir=None, recsin=''):
+    def copy_magnetizing_curves(self, model, dir=None, recsin='', feloss=''):
         """extract mc names from model and write files into workdir or dir if given
 
         Return:
             list of extracted mc names (:obj:`list`)
         """
         dest = dir if dir else self.workdir
+        if isinstance(feloss, (int, float)):
+            try:
+                feloss = {1: 'jordan', 11: 'bertotti'}[int(feloss)]
+            except KeyError:
+                feloss = ''
         return [self.magnetizingCurves.writefile(m[0], dest,
-                                                 fillfac=m[1], recsin=recsin)
+                                                 fillfac=m[1],
+                                                 recsin=recsin,
+                                                 feloss=feloss)
                 for m in model.set_magcurves(
             self.magnetizingCurves, self.magnets)]
 
@@ -212,9 +220,11 @@ class BaseFemag(object):
         self.model = femagtools.model.MachineModel(machine)
         self.modelname = self.model.name
         recsin = ''
+        feloss = ''
         if simulation:
             recsin = simulation.get('recsin', '')
-        self.copy_magnetizing_curves(self.model, recsin=recsin)
+            feloss = simulation.get('calc_fe_loss', '')
+        self.copy_magnetizing_curves(self.model, recsin=recsin, feloss=feloss)
         try:
             if 'wdgdef' in self.model.winding:
                 self.model.winding['wdgfile'] = self.create_wdg_def(
@@ -429,12 +439,15 @@ class BaseFemag(object):
         """
         Read the modelname from the Femag Log file
         """
-        with open(os.path.join(self.workdir, 'FEMAG-FSL.log')) as f:
-            for l in f:
-                if l.startswith('New model') or l.startswith('Load model'):
-                    return l.split('"')[1]
+        try:
+            with open(os.path.join(self.workdir, 'FEMAG-FSL.log')) as f:
+                for l in f:
+                    if l.startswith('New model') or l.startswith('Load model'):
+                        return l.split('"')[1]
+        except FileNotFoundError:
+            pass
 
-        raise ValueError(f"Model not found in {self.workdir}/'FEMAG-FSL.log'")
+        return list(pathlib.Path(self.workdir).glob('*.PROT'))[0].stem
 
     def readResult(self, simulation, bch=None):
         if simulation:
@@ -715,55 +728,6 @@ class FemagTask(threading.Thread):
         self.returncode = self.proc.wait()
 
 
-class SubscriberTask(threading.Thread):
-    def __init__(self, port, host, notify):
-        threading.Thread.__init__(self)
-        context = zmq.Context.instance()
-        self.subscriber = context.socket(zmq.SUB)
-        if not host:
-            host = 'localhost'
-        self.subscriber.connect(f'tcp://{host}:{port}')
-        self.subscriber.setsockopt(zmq.SUBSCRIBE, b'')
-        self.controller = zmq.Context.instance().socket(zmq.PULL)
-        self.controller_url = 'inproc://publisher'
-        self.controller.bind(self.controller_url)
-        self.poller = zmq.Poller()
-        self.poller.register(self.subscriber, zmq.POLLIN)
-        self.poller.register(self.controller, zmq.POLLIN)
-        self.logger = logger
-        self.notify = notify
-
-    def stop(self):
-        socket = zmq.Context.instance().socket(zmq.PUSH)
-        socket.connect(self.controller_url)
-        socket.send(b"quit")
-        socket.close()
-
-    def run(self):
-        self.logger.info("subscriber is ready")
-        while True:
-            socks = dict(self.poller.poll())
-            if socks.get(self.subscriber) == zmq.POLLIN:
-                try:
-                    response = self.subscriber.recv_multipart()
-                    # Sometimes femag send messages with only len = 1. These messages must be ignored
-                    if len(response) < 2:
-                        continue
-                    self.notify([s.decode('latin1') for s in response])
-
-                except Exception:
-                    self.logger.error(
-                        "error in subscription message processing", exc_info=True)
-
-            if socks.get(self.controller) == zmq.POLLIN:
-                req = self.controller.recv()
-                self.logger.info("subscriber %s", req)
-                break
-        self.subscriber.close()
-        self.controller.close()
-        self.logger.debug("subscriber stopped")
-
-
 class ZmqFemag(BaseFemag):
     """Invoke and control execution of FEMAG with ZeroMQ
 
@@ -838,8 +802,8 @@ class ZmqFemag(BaseFemag):
         """attaches a notify function"""
         logger.info("Subscribe on '%s' port %d", self.femaghost, self.port+1)
         if self.subscriber is None:
-            self.subscriber = SubscriberTask(
-                self.port+1, self.femaghost, notify)
+            self.subscriber = femagtools.zmq.SubscriberTask(
+                port=self.port+1, host=self.femaghost, notify=notify)
             self.subscriber.start()
         else:
             # reattach?
@@ -1149,6 +1113,38 @@ class ZmqFemag(BaseFemag):
             logger.warning(response[0])
         return [s.decode('latin1') for s in response]
 
+    def airgap_flux_density(self, pmod):
+        # try to read bag.dat
+        agr = self.getfile("bag.dat")
+        status = json.loads(agr[0])['status']
+        if status == 'ok':
+            datfile = os.path.join(self.workdir, 'bag.dat')
+            with open(datfile, 'wb') as bagfile:
+                bagfile.write(agr[1])
+            agi = ag.read(datfile, pmod)
+        else:
+            import numpy as np
+            # try to read model file (TODO download with getfile)
+            nc = self.read_nc()
+            ag_elmnts = nc.airgap_center_elements
+            logger.info("Airgap elements %d scale_factor %f",
+                        len(ag_elmnts), nc.scale_factor())
+            if len(ag_elmnts) < 1:
+                raise ValueError("Missing airgap elements")
+            scf = 360/nc.scale_factor()/ag_elmnts[-1].center[0]
+            pos = np.array([e.center[0]*scf for e in ag_elmnts])
+            bxy = np.array([e.flux_density() for e in ag_elmnts]).T
+            if np.max(bxy[0]) > np.max(bxy[1]):
+                agi = ag.fft(pos, bxy[0], pmod)
+            else:
+                agi = ag.fft(pos, bxy[1], pmod)
+        return dict(Bamp=agi['Bamp'],
+                    phi0=agi['phi0'],
+                    angle=agi['pos'],
+                    angle_fft=agi['pos'],
+                    B=agi['B'],
+                    B_fft=agi['B_fft'])
+
     def interrupt(self):
         """send push message to control port to stop current calculation"""
         context = zmq.Context.instance()
@@ -1165,7 +1161,7 @@ class ZmqFemag(BaseFemag):
         wdg.write(name, self.workdir)
         self.upload(os.path.join(self.workdir, name+'.WID'))
 
-    def copy_magnetizing_curves(self, model, dir=None, recsin=''):
+    def copy_magnetizing_curves(self, model, dir=None, recsin='', feloss=''):
         """extract mc names from model and write files into workdir or dir if given
            and upload to Femag
 
@@ -1175,9 +1171,16 @@ class ZmqFemag(BaseFemag):
         dest = dir if dir else self.workdir
         mc_names = [m for m in model.set_magcurves(
             self.magnetizingCurves, self.magnets)]
+        if isinstance(feloss, (int, float)):
+            try:
+                feloss = {1: 'jordan', 11: 'bertotti'}[int(feloss)]
+            except KeyError:
+                feloss = ''
         for m in mc_names:
             f = self.magnetizingCurves.writefile(m[0], dest,
-                                                 fillfac=m[1], recsin=recsin)
+                                                 fillfac=m[1],
+                                                 recsin=recsin,
+                                                 feloss=feloss)
             self.upload(os.path.join(dest, f))
         return mc_names
 

femagtools/fsl.py

@@ -158,13 +158,13 @@ class Builder:
         if templ == 'statorFsl':
             #  obsolete
             th_props = [' ']
-            try: 
+            try:
                 th_props = [f'stator_density = {model.stator["density"]}',
                             f'stator_thcond = {model.stator["thcond"]}',
                             f'stator_thcap = {model.stator["thcap"]}',
                             ]
-            except: 
-                pass 
+            except:
+                pass
             if 'parameter' in model.stator['statorFsl']:
                 return self.render_template(
                     model.stator['statorFsl']['content_template'],
@@ -226,20 +226,20 @@ class Builder:
             self.fsl_rotor = True
             #  obsolete
             th_props = [' ']
-            try: 
+            try:
                 logger.info(model.magnet)
                 th_props = [f'rotor_density = {model["magnet"]["density"]}',
                             f'rotor_thcond = {model["magnet"]["thcond"]}',
                             f'rotor_thcap = {model["magnet"]["thcap"]}'
                             ]
-            except: 
-                pass 
+            except:
+                pass
             if 'parameter' in model.magnet['magnetFsl']:
                 return mcv + self.render_template(
                     model.magnet['magnetFsl']['content_template'],
                     model.magnet['magnetFsl']['parameter']) + th_props
             elif model.magnet['magnetFsl'].get('content'):
-                return mcv + model.magnet['magnetFsl']['content'].split('\n') 
+                return mcv + model.magnet['magnetFsl']['content'].split('\n')
             if isinstance(model.magnet['magnetFsl']
                           ['content_template'], str):
                 with open(model.magnet['magnetFsl']
@@ -248,7 +248,7 @@ class Builder:
             else:
                 templ = model.magnet['magnetFsl']['content_template']
             return mcv + self.render_template(
-                '\n'.join(templ), 
+                '\n'.join(templ),
                 model.magnet['magnetFsl'])
 
         templ = model.magnettype()
@@ -364,8 +364,8 @@ class Builder:
         """return connect_model if rotating machine and incomplete model
         (Note: femag bug with connect model)"
         """
-        if (model.get('move_action') == 0 and (
-                model.connect_full or
+        if (model.connect_full or (
+                model.get('move_action', 0) == 0 and
                 model.stator['num_slots'] > model.stator['num_slots_gen'])):
             fslcmds = ['pre_models("connect_models")\n']
             if 'thcond' in model.stator:
@@ -556,7 +556,7 @@ class Builder:
         if 'fsl_rotor' in conv:
             self.fsl_rotor = True
             th_props = ['']
-            logger.info(model['magnet'])
+            logger.debug(model['magnet'])
             if hasattr(model, 'magnet'):
                 if model['magnet'].get('thcond', 0):
                     th_props = [f'rotor_density = {model["magnet"]["density"]}',
@@ -730,7 +730,7 @@ class Builder:
         custom_fefunc = ['']
         if pfefunc:
             sim['loss_funct'] = 1 # 3?
-            if pfefunc == 'bertotti' or 'modified_steinmetz':
+            if pfefunc in ('bertotti', 'modified_steinmetz'):
                 custom_fefunc = self.__render(sim['PVFE_FSL'], pfefunc)
             else:
                 custom_fefunc = pfefunc.split('\n')
@@ -750,6 +750,9 @@ class Builder:
             revert_displ = self.create_displ_stator_rotor(
                 sim['eccentricity'])
 
+        if sim.get('calculationMode') == 'pm_sym_f_cur':
+            if 'nload_ex_cur' in sim.keys():  # convert obsolete key
+                sim['noload_ex_cur'] = sim.pop('nload_ex_cur')
         felosses = custom_fefunc + self.create_fe_losses(sim)
         fslcalc = (displ_stator_rotor
                    + self.__render(sim, sim.get('calculationMode'))

femagtools/isa7.py

@@ -815,8 +815,9 @@ class Isa7(object):
                             airgap_positions.append(axy[0][0])
                         self.airgap_center_elements.append(se.elements)
 
-            if len(self.airgap_center_elements) == 1:
-                self.airgap_center_elements = self.airgap_center_elements[0]
+            if self.airgap_center_elements:
+                # TODO check airgap center
+                self.airgap_center_elements = self.airgap_center_elements[-1]
                 if horiz:
                     airgap_positions.append(np.min(nxy[:, 1]))
                 else:

femagtools/machine/__init__.py

@@ -68,8 +68,9 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
         psid = rwdg*rlfe*dqp['psid']
         psiq = rwdg*rlfe*dqp['psiq']
         losses = __scale_losses(dqp['losses'], rlfe)
-        losses['ef'] = dqpars[-1]['losses']['ef']
-        losses['eh'] = dqpars[-1]['losses']['ef']
+        losses['ef'] = dqpars[-1]['losses'].get('ef', [2.0, 2.0])
+        losses['hf'] = dqpars[-1]['losses'].get('hf', [1.0, 1.0])
+        # TODO handle bertotti excess loss factor
 
         if 'psidq' in eecpars:
             machine = PmRelMachinePsidq(
@@ -140,7 +141,7 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             try:
                 losses = __scale_losses(bch.psidq['losses'], rlfe)
                 losses['ef'] = bch.lossPar.get('ef', [2.0, 2.0])
-                losses['eh'] = bch.lossPar.get('eh', [1.0, 1.0])
+                losses['hf'] = bch.lossPar.get('hf', [1.0, 1.0])
             except KeyError:
                 losses = {}
             if 'ex_current' in bch.machine:
@@ -162,7 +163,7 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             try:
                 losses = __scale_losses(bch.ldq['losses'], rlfe)
                 losses['ef'] = bch.lossPar.get('ef', [2.0, 2.0])
-                losses['eh'] = bch.lossPar.get('eh', [1.0, 1.0])
+                losses['hf'] = bch.lossPar.get('hf', [1.0, 1.0])
             except KeyError:
                 losses = {}
             if 'ex_current' in bch.machine:

femagtools/machine/afpm.py

@@ -25,6 +25,30 @@ AFM_TYPES = (
     "S2R1_all"   # 2 stator, 1 rotor, all simulated
 )
 
+def num_agnodes(Q, p, pw, ag):
+    """return total number of nodes in airgap per pole
+     Args:
+      Q: (int) number of slots
+      p: (int) number of pole pairs
+      pw: (float) pole width
+      ag: (float) airgap height
+    """
+    num_nodes = np.arange(6, 120, 6)
+    i = np.argmin(np.abs(pw/num_nodes - ag/2))
+    nag = num_nodes[i-1]
+    if p*nag % Q:
+        lcm = np.lcm(Q, 2*p)//p
+        nmin, nmax = 1, num_nodes[-1]//lcm
+        num_nodes = np.array(
+            [i*lcm for i in range(nmin, nmax) if i*lcm % 6 == 0])
+        i = np.argmin(np.abs(pw/num_nodes - ag/2))
+        if i > 0:
+            nag = num_nodes[i-1]
+        else:
+            nag = num_nodes[i]
+        # TODO nodedist 0.5, 2, 4, 6
+    return nag
+
 def _integrate(radius, pos, val):
     interp = RegularGridInterpolator((radius, pos), val)
     def func(x, y):
@@ -141,11 +165,8 @@ def parident(workdir, engine, temp, machine,
 
     if "num_agnodes" not in machine:
         for pw in pole_width:
-            machine['num_agnodes'] = 6*round(pw/machine['airgap']/4)
-
-            #if machine['num_agnodes'] < nper:
-            #    machine['num_agnodes'] = 8*round(pw/machine['airgap']/4)
-
+            machine['num_agnodes'] = num_agnodes(Q1, p//2, pw,
+                                                 machine['airgap'])
     nlparvardef = {
         "decision_vars": [
             {"values": pole_width,
@@ -165,13 +186,13 @@ def parident(workdir, engine, temp, machine,
     parvardef = {
         "decision_vars": [
             #            {"values": sorted(2*temp), "name": "magn_temp"},
-            {"steps": num_beta_steps, "bounds": [beta_min, 0], "name": "angl_i_up"},
+            {"steps": num_beta_steps, "bounds": [beta_min, 0],
+             "name": "angl_i_up"},
             {"steps": num_cur_steps,
              "bounds": [i1_max/num_cur_steps, i1_max], "name": "current"}
         ]
     }
 
-
     ldq = []
     for magtemp in temp:
         nlcalc = dict(
@@ -189,7 +210,8 @@ def parident(workdir, engine, temp, machine,
 
             nlresults = pstudy(nlparvardef, machine, nlcalc, engine)
             if nlresults['status'].count('C') != len(nlresults['status']):
-                raise ValueError('Noload simulation failed %s', nlresults['status'])
+                raise ValueError(
+                    f"Noload simulation failed {nlresults['status']}")
         else:
             nlresults = {"x": [], "f": []}
             i = 0
@@ -210,7 +232,7 @@ def parident(workdir, engine, temp, machine,
                 nlresults['f'].append({k: v for k, v in r.items()})
                 i = i + 1
         nlresults.update(process(lfe, pole_width, machine, nlresults['f']))
-
+        weights = nlresults['weights']
         current_angles = nlresults['f'][0]['current_angles']
         results = []
         i = 0
@@ -325,7 +347,7 @@ def parident(workdir, engine, temp, machine,
                                       (-1, num_beta_steps)),
                            axis=1).T.tolist()})
         ldq.append({'temperature': magtemp,
-                    'i1':i1, 'beta':beta,
+                    'i1': i1, 'beta': beta,
                     'psid': psid.tolist(), 'psiq': psiq.tolist(),
                     'ld': ld, 'lq': lq,
                     'torque': torque.tolist(),
@@ -334,7 +356,8 @@ def parident(workdir, engine, temp, machine,
         #iq, id = femagtools.machine.utils.iqd(*np.meshgrid(beta, i1))
 
     return {'m': machine[wdgk]['num_phases'],
-            'p': machine['poles']//2,
+            'p': machine['poles']//2, 'weights': weights,
+            'rotor_mass': sum(weights[1]), "kfric_b": 1,
             'ls1': 0, 'r1': r1, 'ldq': ldq}
 
 
@@ -362,7 +385,7 @@ def process(lfe, pole_width, machine, bch):
     num_slots = machine['stator']['num_slots']
     mmod = model.MachineModel(machine)
     slots_gen = mmod.stator['num_slots_gen']
-    scale_factor =_get_scale_factor(model_type, num_slots, slots_gen)
+    scale_factor = _get_scale_factor(model_type, num_slots, slots_gen)
     endpos = [2*pw*1e3 for pw in pole_width]
     displ = [[d for d in r['linearForce'][0]['displ']
               if d < e*(1+1/len(r['linearForce'][0]['displ']))]
@@ -373,11 +396,14 @@ def process(lfe, pole_width, machine, bch):
     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():
+            raise ValueError(
+                f"inhomogenous number of steps: {[len(d) for d in displ]}")
+        lfx = [r['linearForce'][0]['force_x'] for r in bch]
         torque = _integrate(radius, rotpos[0], np.array(
             [r*scale_factor*np.array(fx[:-1])/l
-             for l, r, fx in zip(lfe, radius,
-                                 [r['linearForce'][0]['force_x']
-                                  for r in bch])]))
+             for l, r, fx in zip(lfe, radius, lfx)]))
 
         voltage = {k: [scale_factor * np.array(ux[:-1])/l
                        for l, ux in zip(lfe, [r['flux'][k][0]['voltage_dpsi']
@@ -385,6 +411,13 @@ def process(lfe, pole_width, machine, bch):
                    for k in bch[0]['flux']}
         emf = [_integrate(radius, rotpos[0], np.array(voltage[k]))
                for k in voltage]
+
+        fluxxy = {k: [scale_factor * np.array(flx[:-1])/l
+                      for l, flx in zip(lfe, [r['flux'][k][0]['flux_k']
+                                              for r in bch])]
+                  for k in bch[0]['flux']}
+        flux = [_integrate(radius, rotpos[0], np.array(fluxxy[k]))
+                for k in fluxxy]
     else:
         r = radius[0]
         torque = [r*scale_factor*fx
@@ -393,6 +426,7 @@ 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]
+        flux = [fluxxy[k][:n] for k in fluxxy]
 
     pos = (rotpos[0]/np.pi*180)
     emffft = utils.fft(pos, emf[0])
@@ -442,10 +476,20 @@ def process(lfe, pole_width, machine, bch):
                         mmod.outer_diam, mmod.inner_diam)
     i1 = np.mean([np.max(c) for c in currents])/np.sqrt(2)
     plcu = mmod.winding['num_phases']*i1**2*r1
+    weights = np.array([[0, 0, 0], [0, 0, 0]])
+    try:
+        for b in bch:
+            weights = weights + b['weights']
+        weights *= scale_factor
+    except KeyError as exc:
+        #logger.warning("missing key %s", exc)
+        pass
 
     return {
+        'weights': weights.tolist(),
         'pos': pos.tolist(), 'r1': r1,
         'torque': torque,
+        'flux_k': flux,
         'emf': emf,
         'emf_amp': emffft['a'], 'emf_angle': emffft['alfa0'],
         'freq': freq,
@@ -563,10 +607,10 @@ class AFPM:
     condMat: conductor material
     """
     def __init__(self, workdir, magnetizingCurves='.', magnetMat='',
-                 condMat=''):
+                 condMat='', cmd=None):
         self.parstudy = parstudy.List(
             workdir, condMat=condMat, magnets=magnetMat,
-            magnetizingCurves=magnetizingCurves)
+            magnetizingCurves=magnetizingCurves, cmd=cmd)
 
     def __call__(self, engine, machine, simulation, num_slices):
         """ run FE simulation
@@ -603,14 +647,12 @@ class AFPM:
                     for pw in pole_width]
 
         if "num_agnodes" not in machine:
+            Q1 = machine['stator']['num_slots']
+            p = machine['poles']
             for pw in pole_width:
-                machine['num_agnodes'] = 6*round(pw/machine['airgap']/4)
-                #Q = machine['stator']['num_slots']
-                #p = machine['poles']
-                #nper = np.lcm(Q, p)
-                #if machine['num_agnodes'] < nper:
-                #    machine['num_agnodes'] = 8*round(pw/machine['airgap']/4)
-
+                machine['num_agnodes'] = num_agnodes(Q1, p//2, pw,
+                                                     machine['airgap'])
+            logger.info("Num agnodes/pole %d", machine['num_agnodes'])
         parvardef = {
             "decision_vars": [
                 {"values": pole_width,
@@ -622,21 +664,24 @@ class AFPM:
         }
         machine['pole_width'] = np.pi * machine['inner_diam']/machine['poles']
         machine['lfe'] = machine['outer_diam'] - machine['inner_diam']
-
+        simulation['skew_displ'] = (simulation.get('skew_angle', 0)/180 * np.pi
+                                    * machine['inner_diam'])
         nlresults = {}
-        if (simulation['calculationMode'] != 'cogg_calc' and
-            'poc' not in simulation):
+        if (simulation['calculationMode'] != 'cogg_calc'
+            and 'poc' not in simulation):
             nlcalc = dict(
                 calculationMode="cogg_calc",
                 magn_temp=simulation.get('magn_temp', 20),
                 num_move_steps=60,
+                skew_linear=0,
+                skew_steps=0,
                 poc=poc.Poc(machine['pole_width']),
                 speed=0)
             logging.info("Noload simulation")
             nlresults = self.parstudy(parvardef,
                                       machine, nlcalc, engine)
             if nlresults['status'].count('C') != len(nlresults['status']):
-                raise ValueError('Noload simulation failed %s', nlresults['status'])
+                raise ValueError(f'Noload simulation failed {nlresults["status"]}')
             nlresults.update(process(lfe, pole_width, machine, nlresults['f']))
 
             current_angles = nlresults['f'][0]['current_angles']
@@ -645,14 +690,15 @@ class AFPM:
                 parameters={
                     'phi_voltage_winding': current_angles})
             logger.info("Current angles: %s", current_angles)
-        elif (simulation['calculationMode'] == 'cogg_calc' and
-            'poc' not in simulation):
+        elif (simulation['calculationMode'] == 'cogg_calc'
+            and 'poc' not in simulation):
             simulation['poc'] = poc.Poc(machine['pole_width'])
 
         lresults = self.parstudy(
-            parvardef,
-            {k: machine[k] for k in machine if k!= 'afm_rotor'},
-            simulation, engine)  # Note: imcomplete machine prevents rebuild
+            parvardef, machine, simulation, engine)
+        if lresults['status'].count('C') != len(lresults['status']):
+            raise ValueError(
+                f'{simulation["calculationMode"]} failed {lresults["status"]}')
 
         results = process(lfe, pole_width, machine, lresults['f'])
         if nlresults: