femagtools 1.8.2__py3-none-any.whl → 1.8.4__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

@@ -556,7 +556,6 @@ class Builder:
         if 'fsl_rotor' in conv:
             self.fsl_rotor = True
             th_props = ['']
-            logger.info(model['magnet'])
             if hasattr(model, 'magnet'):
                 if model['magnet'].get('thcond', 0):
                     th_props = [f'rotor_density = {model["magnet"]["density"]}',
@@ -730,7 +729,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 +749,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/afpm.py

@@ -11,7 +11,7 @@ from .. import model
 from .. import utils
 from .. import windings
 from .. import femag
-from scipy.interpolate import RegularGridInterpolator, interp1d, RectBivariateSpline
+from scipy.interpolate import make_interp_spline, RegularGridInterpolator, RectBivariateSpline
 from scipy.integrate import quad
 import copy
 
@@ -33,16 +33,21 @@ def num_agnodes(Q, p, pw, ag):
       pw: (float) pole width
       ag: (float) airgap height
     """
-    num_nodes = np.arange(12, 120, 6)
+    num_nodes = np.arange(6, 120, 6)
     i = np.argmin(np.abs(pw/num_nodes - ag/2))
-    if p*num_nodes[i-1] % Q:
+    nag = num_nodes[i-1]
+    if p*nag % Q:
         lcm = np.lcm(Q, 2*p)//p
-        nmin, nmax = num_nodes[0]//lcm, num_nodes[-1]//lcm
+        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))
-        # nodedist 0.5, 2, 4, 6
-    return num_nodes[i-1]
+        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)
@@ -53,7 +58,7 @@ def _integrate(radius, pos, val):
 
 
 def _integrate1d(radius, val):
-    interp = interp1d(radius, val)
+    interp = make_interp_spline(radius, val, k=1)
     def func(x):
         return interp((x))
     return quad(func, radius[0], radius[-1])[0]
@@ -162,7 +167,6 @@ def parident(workdir, engine, temp, machine,
         for pw in pole_width:
             machine['num_agnodes'] = num_agnodes(Q1, p//2, pw,
                                                  machine['airgap'])
-
     nlparvardef = {
         "decision_vars": [
             {"values": pole_width,
@@ -182,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(
@@ -381,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']))]
@@ -392,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']
@@ -404,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
@@ -412,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])
@@ -474,6 +489,7 @@ def process(lfe, pole_width, machine, bch):
         '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,
@@ -591,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
@@ -648,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']
@@ -671,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:

femagtools/machine/effloss.py

@@ -39,7 +39,7 @@ def iqd_tmech_umax(m, u1, with_mtpa, progress, speed_torque, iq, id, iex):
     finally:
         progress.close()
 
-def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa):
+def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa, publish=0):
     """calculate iqd for sm and pm using multiproc
     """
     progress_readers = []
@@ -79,6 +79,16 @@ def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa):
                 progress_readers.remove(r)
             else:
                 if i % len(progress_readers) == 0:
+                    if publish:
+                        numTot = len(collected_msg)
+                        numOf = f"{num_proc-numTot} of {num_proc}"
+                        workdone = sum([float(i[:-1])
+                                        for i in collected_msg]) / numTot
+                        logger.debug("numTot %d numOf %s workdone %s, %s",
+                                     numTot, numOf, workdone, collected_msg)
+                        publish(('progress_logger',
+                                 f"{numTot}:{numOf}:{workdone}:"))
+                        # {' '.join(collected_msg)}"))
                     logger.info("Losses/Eff Map: %s",
                                 ', '.join(collected_msg))
                     collected_msg = []
@@ -156,9 +166,9 @@ def _generate_mesh(n, T, nb, Tb, npoints):
         nmax = max(n)
         tmin, tmax = 0, max(T)
         tnum = npoints[1]
-    tip = ip.interp1d(n, T)
+    tip = ip.make_interp_spline(n, T, k=1)
     if nb and Tb:
-        tbip = ip.interp1d(nb, Tb)
+        tbip = ip.make_interp_spline(nb, Tb, k=1)
     else:
         def tbip(x): return 0
 
@@ -197,7 +207,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
       with_mtpa -- (optional) use mtpa if True (default), disables mtpv if False
       with_tmech -- (optional) use friction and windage losses (default)
       num_proc -- (optional) number of parallel processes (default 0)
-      progress  -- (optional) custom function for progress logging
+      progress  -- (optional) custom function for progress logging (publishing)
       with_torque_corr -- (optional) T is corrected if out of range (default False)
 
     Returns:
@@ -250,41 +260,42 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     logger.info("total speed,torque samples %d", ntmesh.shape[1])
     if isinstance(m, (PmRelMachine, SynchronousMachine)):
         if num_proc > 1:
-            iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa)
+            iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa,
+                                       publish=progress)
         else:
             class ProgressLogger:
-                def __init__(self, nsamples):
+                def __init__(self, nsamples, publish):
                     self.n = 0
+                    self.publish = publish
                     self.nsamples = nsamples
                     self.num_iv = round(nsamples/15)
                 def __call__(self, iqd):
                     self.n += 1
                     if self.n % self.num_iv == 0:
-                        logger.info("Losses/Eff Map: %d%%",
-                                    round(100*self.n/self.nsamples))
-            if progress is None:
-                progress = ProgressLogger(ntmesh.shape[1])
-            else:
-                try:
-                    progress.nsamples=ntmesh.shape[1]
-                    progress(0)  # To check conformity
-                    progress.n = 0
-                except:
-                    logger.warning("Invalid ProgressLogger given to efficiency_losses_map, using default one!")
-                    progress = ProgressLogger(ntmesh.shape[1])
+                        workdone=round(100*self.n/self.nsamples)
+                        if self.publish:
+                            self.publish(
+                                ('progress_logger',
+                                 f"{self.n}:{self.n} of {self.nsamples}:{workdone}"))
+                        logger.info("Losses/Eff Map: %d%%", workdone)
+
+            progress_logger = ProgressLogger(ntmesh.shape[1], progress)
+            progress_logger.nsamples = ntmesh.shape[1]
+            progress_logger(0)  # To check conformity
+            progress_logger.n = 0
             if with_tmech:
                 iqd = np.array([
                     m.iqd_tmech_umax(
                         nt[1],
                         2*np.pi*nt[0]*m.p,
-                        u1, log=progress, with_mtpa=with_mtpa)[:-1]
+                        u1, log=progress_logger, with_mtpa=with_mtpa)[:-1]
                     for nt in ntmesh.T]).T
             else:
                 iqd = np.array([
                     m.iqd_torque_umax(
                         nt[1],
                         2*np.pi*nt[0]*m.p,
-                        u1, log=progress, with_mtpa=with_mtpa)[:-1]
+                        u1, log=progress_logger, with_mtpa=with_mtpa)[:-1]
                     for nt in ntmesh.T]).T
 
         beta, i1 = betai1(iqd[0], iqd[1])

femagtools/machine/im.py

@@ -35,6 +35,9 @@ def log_interp1d(x, y, kind='cubic'):
     logy = np.log10(yy)
     lin_interp = ip.interp1d(logx, logy, kind=kind, fill_value="extrapolate")
     def log_interp(zz): return np.power(10.0, lin_interp(np.log10(zz)))
+    # TODO check replace interp1d
+    #lin_interp = ip.make_interp_spline(logx, logy, bc_type='not-a-knot')
+    #def log_interp(zz): return np.power(10.0, lin_interp(np.log10(zz), nu=1))
     return log_interp
 
 
@@ -792,15 +795,10 @@ def parident(workdir, engine, f1, u1, wdgcon,
     tend = time.time()
     logger.info("Elapsed time %d s Status %s",
                 (tend-tstart), status)
+    if any([x != 'C' for x in status]):
+        raise ValueError("AC simulation failed")
     # collect results
-    results = []
-    errors = []
-    for t in job.tasks:
-        if t.status == 'C':
-            results.append(t.get_results())
-        else:
-            logger.warning("Status %s", t.status)
-            results.append({})
+    results = [t.get_results() for t in job.tasks]
 
     i1_0 = results[0]['i1_0'].tolist()
     psi1_0 = results[0]['psi1_0'].tolist()

femagtools/machine/sizing.py

@@ -628,8 +628,9 @@ def get_sm_rotor_dimensions(A, psi1, lfe, Da2, par):
     mue0 = 4*np.pi*1e-7
 
     wf = wp - wc
-    anr = par['airgap']*par['Ba']/mue0/par['J']/par['kqr']
-
+    NI = par['airgap']*par['Ba']/mue0
+    anr = NI/par['J']/par['kqr']
+    r['NI'] = NI
     a = np.tan(alphap/2)/2
     b = (wp/2 - wc + np.tan(alphap/2)*(Da2/2 - hp))/2
     hc = min(max(4*anr/(wc+wp), 0.75*hfmax), hfmax)
@@ -827,7 +828,7 @@ def afpm(pnom: float, speed: float, p: int, afmtype: str, **kwargs) -> dict:
     bns = taus*(Di+2*hs1) - bds
 
     hns = (-bns + np.sqrt(bns**2 + 4*ans*np.tan(taus)))/2/np.tan(taus)/kps
-    hys = psi1/lfe/par['By']/kps
+    hys = psi1/2/lfe/par['By']/kps
 
     aw = ans * par['kq'] / layers / num_wires * kps