femagtools 1.8.6__tar.gz → 1.8.8__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: femagtools
-Version: 1.8.6
+Version: 1.8.8
 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.6 → femagtools-1.8.8}/src/femagtools/__init__.py

@@ -2,10 +2,10 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.6'
+__version__ = '1.8.8'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
-__copyright__ = 'Copyright 2023-2024 Gamma Technology'
+__copyright__ = 'Copyright 2023-2025 Gamma Technology'
 
 from .asm import read
 from .bch import Reader

femagtools-1.8.8/src/femagtools/amela.py

@@ -0,0 +1,141 @@
+'''Calculate Magnet Losses with AMELA
+
+'''
+import sys
+import json
+import pathlib
+import logging
+from pathlib import Path
+import femagtools.nc
+import numpy as np
+from numpy import pi, sin, cos
+import subprocess
+
+#  set logging
+logger = logging.getLogger(__name__)
+
+
+class Amela():
+    '''Run Amela Calculation
+
+    Args:
+      workdir : working directory of femag calculation
+        (The directory that includes the nc file)
+      amela_dir: str (optional) amela directory
+      magnet_data : calculation control name must be provided
+        dict(name='test',
+        -- the following parameters are optional
+             mur=1.05,
+             sigma=625000,
+             hm=3,
+             wm=20,
+             lm=30,
+             speed=1000,
+             nsegwid=0,
+             nseglen=0)
+    '''
+
+    def __init__(self, workdir: str, magnet_data: dict,
+                 amela_dir=None):
+
+        self.magn = magnet_data
+        self.workdir = pathlib.Path(workdir)
+        if amela_dir is not None:
+            self.amela_dir = pathlib.Path(amela_dir)
+        else:
+            self.amela_dir = self.workdir
+
+        self.jsonfile = []
+        if sys.platform == 'win32':
+            self.cmd = [str(self.amela_dir / 'AMELA.BAT')]
+        else:
+            self.cmd = [str(self.amela_dir / 'AMELA')]
+        # default batch
+        self.cmd.append('--b')
+        # append calc options
+        if 'speed' in self.magn:
+            self.cmd.append(f"--speed {self.magn['speed']}")
+        if 'nsegwid' in self.magn:
+            self.cmd.append(f"--nsegwid {self.magn['nsegwid']}")
+        if 'nseglen' in self.magn:
+            self.cmd.append(f"--nseglen {self.magn['nseglen']}")
+
+    def get_magnet_data_all(self, num_op):
+        '''get all magnet data for all loadcases'''
+        nc_name = self.workdir / self.magn['name']
+        r = femagtools.nc.read(nc_name)
+        return [r.get_magnet_data(ibeta=i) for i in num_op]
+
+    def export_json(self, pm_data: list):
+        '''Export magnet data to json files
+
+        Args:
+          pm_data: list of magnet data
+
+        '''
+        return
+        pm_dir = self.amela_dir / self.magn['name']
+        pm_dir.mkdir(exist_ok=True)
+        for i in pm_data:
+            filename = (pm_dir / i['name']).with_suffix('.json')
+            self.jsonfile.append(str(filename))  # for the future use
+            # pop out non necessary data
+            i.pop('bl')
+            i.pop('elcp')
+            with filename.open('w') as f:
+                json.dump(i, f)
+            logger.info('Exporting %s ...', i['name'])
+
+    def read_loss(self, pm_data: dict) -> dict:
+        '''Read magnet losses
+
+        Args:
+          pm_data : dict
+
+        Returns:
+          losses
+        '''
+        losses = {}
+        for i in range(len(pm_data)):
+            dirname = self.magn['name'] + '/' + pm_data[i]['name'] + \
+                '/EClosses.tab'
+            result_name = self.amela_dir / dirname
+            with result_name.open() as f:
+                data = np.loadtxt(f)
+                total_loss = np.mean(data[0:-1, -1])
+                losses[pm_data[i]['name']] = {"loss_data":data, "total_loss": total_loss}
+                logger.info("Magnet losses in superelement %s is %.3f W",
+                            pm_data[i]['name'].split('se')[-1], total_loss)
+        return losses
+
+    def __call__(self, ialh=False) -> dict:
+        '''Run amela calculation
+
+        Args:
+          ialh: use method IALH if True else 3DI
+
+        Returns:
+            losses
+        '''
+        # get magnet data
+        nc_name = self.workdir / self.magn['name']
+        nc = femagtools.nc.read(nc_name)
+        num_cases = nc.el_fe_induction_1.shape[3] - 1
+        if 'loadcase' in self.magn:
+            indx = self.magn['loadcase'] - 1
+        else:
+            indx = num_cases
+        if indx == 3:
+            indx = num_cases  # avoid error
+
+        r = nc.get_magnet_data(indx)
+        # export to json
+        #self.export_json(r)
+        # run amela
+        calc_method = 'IALH' if ialh else '3DI'
+        cmd = self.cmd + ['--calc', calc_method, self.magn['name'] + '/']
+        log_file = self.amela_dir / 'amela.out'
+        logger.info("Calculating magnet losses with AMELA ...")
+        with log_file.open('w') as output:
+            subprocess.run(cmd, stdout=output)
+        return self.read_loss(r)

{femagtools-1.8.6 → femagtools-1.8.8}/src/femagtools/bch.py

@@ -1057,10 +1057,11 @@ class Reader:
         e.g. : idList[-450, -350, -250, -150, -50, 0]
                idList[-500, -400, -300, -200, -100, 0, 0]
         '''
-        diff = np.floor(np.abs(np.diff(idList)))
-        if idList[-1] == 0 and len(idList) > 2 and \
-           diff[-1] == 0:
+        if list(idList).count(0) > 1: # femag writes duplicate id==0 values
             idList = idList[:-1]
+        diff = np.floor(np.abs(np.diff(idList)))
+        if n := np.trim_zeros(np.diff(diff)).size:
+            idList = idList[:-n]
         return idList
 
     def __read_psidq(self, content):
@@ -1085,8 +1086,7 @@ class Reader:
             ncols = ncols-1
 
         id = np.reshape(m[0], (-1, ncols)).T[0]
-        if id[0] >= 0:
-            id = self.__removeTrailingZero(id)
+        id = self.__removeTrailingZero(id)
         nrows = len(id)
         if nrows > 1 and id[nrows-1] < id[nrows-2]:
             nrows = nrows-1
@@ -1121,8 +1121,7 @@ class Reader:
             ncols = ncols-1
 
         id = np.reshape(m[0], (-1, ncols)).T[0]
-        if id[0] >= 0:
-            id = self.__removeTrailingZero(id)
+        id = self.__removeTrailingZero(id)
         nrows = len(id)
         if nrows > 1 and id[nrows-1] < id[nrows-2]:
             nrows = nrows-1
@@ -1610,6 +1609,11 @@ class Reader:
                         losses['staza'] = floatnan(rec[0])
                         losses['stajo'] = floatnan(rec[1])
                         losses['total'] += losses['staza']+losses['stajo']
+
+                    elif content[i+1].split() == ['Iron', '----']:
+                        losses['rotfe'] = sum([floatnan(x) for x in rec])
+                        losses['total'] += losses['rotfe']    
+                        
                     else:
                         losses['rotfe'] = floatnan(rec[1])
                         losses['total'] += losses['rotfe']

{femagtools-1.8.6 → femagtools-1.8.8}/src/femagtools/ecloss.py

@@ -5,7 +5,6 @@ __author__ = 'Max Hullmann, Dapu Zhang, Ivan Solc'
 
 import logging
 import warnings
-from .amela import Amela
 import numpy as np
 from numpy import sinh, sin, cosh, cos, pi
 from scipy.interpolate import RBFInterpolator
@@ -22,6 +21,7 @@ class FrequencyDomain:
         self.phase = s['phase']
         self.order = s['order']
 
+
 def fd(s):
     f = FrequencyDomain(s)
     return f
@@ -53,10 +53,10 @@ def fft(s, fs):
     freq = np.array([i*fs/l for i in range(ll)])
 
     return fd(dict(cmplx_amp=mag,
-                    amp=amp,
-                    freq=freq,
-                    phase=np.angle(mag[0:ll]),
-                    order=freq/freq[idx_max]))
+                   amp=amp,
+                   freq=freq,
+                   phase=np.angle(mag[0:ll]),
+                   order=freq/freq[idx_max]))
 
 def dfac(x):
     return 6/(x)**3*(sinh(x)-sin(x))/ \
@@ -76,7 +76,7 @@ def nptns(x, x1, nx):
 
 def ngrid(wm, hm, elxy):
     '''calculate number of grid points for the interpolation'''
-    be = np.sqrt(wm*hm/elxy['excp'].shape[0])
+    be = np.sqrt(wm*hm/elxy['ecp'].shape[0])
     nx = np.around(wm/be) + 1
     ny = np.around(hm/be) + 1
 
@@ -91,13 +91,15 @@ def ngrid(wm, hm, elxy):
 
 def binterp(x, y, xq, yq, b):
     '''interpolate flux density with Rbf interpolator'''
-    f = RBFInterpolator(np.array([[i, j] for i, j in zip(x, y)]), b)
-    inp = f(np.array([[i, j] for i, j in zip(xq, yq)]))
+    f = RBFInterpolator(np.vstack((x, y)).T, b)
+    inp = f(np.vstack((xq, yq)).T)
     return inp.reshape(len(np.unique(yq)), len(np.unique(xq)), -1)
 
 def binterp_ialh2(x, y, xq, yq, b):
     '''interpolate flux density with Rbf interpolator'''
-    f = RBFInterpolator(np.array([[i, j] for i, j in zip(x, y)]), b, kernel='thin_plate_spline')
+    yy = np.vstack((x, y)).T
+    logger.debug("shape y %s b %s", yy.shape, np.shape(b))
+    f = RBFInterpolator(yy, b, kernel='thin_plate_spline')
     inp = f(np.array([[i, j] for i, j in zip(xq, yq)]))
     return inp.reshape(len(np.unique(xq)), -1)
 
@@ -113,7 +115,7 @@ def Segmentation(wm, hm, lm, elxy, nsegx, nsegy, nsegz):
              x,y coordinates of each element's centerpoint in local reference frame, for entire magnet - xx, yy
     '''
     # Default nx,ny,nz without considering the segmentation
-    be = np.sqrt(wm*hm/elxy['excp'].shape[0])  #square elements
+    be = np.sqrt(wm*hm/np.shape(elxy['ecp'])[1])  #square elements
     nx_new = int(np.around(wm/be))
     ny_new = int(np.around(hm/be))
     nz_new = int(np.around(lm/be))
@@ -126,8 +128,8 @@ def Segmentation(wm, hm, lm, elxy, nsegx, nsegy, nsegz):
 
     wms = wm/nsegx
     hms = hm/nsegy
-    x0 = 0 # offset for excpl
-    y0 = 0 # offset for eycpl
+    x0 = 0 # offset for ecpl
+    y0 = 0 # offset for ecpl
 
     segxcpl = np.linspace(wms/2/nx_new, wms - wms/nx_new/2, nx_new) + x0 # x center points of wanted elements distribution, local ref frame, 1st segment
     segycpl = np.linspace(hms/2/ny_new, hms - hms/ny_new/2, ny_new) + y0 # y center points of wanted elements distribution, local ref frame, 1st segment
@@ -149,21 +151,33 @@ def Segmentation(wm, hm, lm, elxy, nsegx, nsegy, nsegz):
 
     return nx_new, ny_new, nz_new, xx, yy
 
-class MagnLoss(Amela):
+class MagnLoss:
     '''Calculate Magnet Losses with IALH Methode
     Parameters
     ----------
-    workdir: working directory
-    modelname: name of the femag model (*.nc)
+    nc: (object) nc/isa7
     ibeta: load cases [0, 1, 2]
+    magnet_data: array of pm data (see nc/isa7 get_magnet_data)
     '''
-    def __init__(self, workdir, modelname, ibeta, **kwargs):
-        super().__init__(workdir, magnet_data=dict(name=modelname))
-        self.pm = self.get_magnet_data_all(ibeta)
-        self.theta = self.pm[-1][-1]['phi'] # rotor pos
+    def __init__(self, **kwargs):
+        #super().__init__(workdir, magnet_data=dict(name=modelname))
+        if 'nc' in kwargs:
+            ibeta = kwargs.get('ibeta', [0])
+            nc = kwargs['nc']
+            self.pm = [nc.get_magnet_data(ibeta=i) for i in ibeta]
+        elif 'magnet_data' in kwargs:
+            self.pm = kwargs['magnet_data']
         self.speed = kwargs.get('speed', self.pm[-1][-1]['speed'])
-        self.tgrid = 60/self.speed*(self.theta[-1] - self.theta[0])/360
-        self.lt = len(self.theta)
+        logger.info("Speed %f", self.speed)
+        try:  # move action rotation
+            self.theta = self.pm[-1][-1]['phi'] # rotor pos
+            self.lt = len(self.theta)
+            self.tgrid = 60/self.speed*(self.theta[-1]-self.theta[0])/360
+        except: # move action linear
+            self.displ = self.pm[-1][-1]['displ'] # rotor pos
+            self.lt = len(self.displ)
+            self.tgrid = (self.displ[-1]-self.displ[0])/self.speed
+
         self.ls = self.pm[-1][-1]['ls']
         self.th_loss = []
         try:
@@ -187,7 +201,6 @@ class MagnLoss(Amela):
             self.lm = 0
 
         self.segz = kwargs.get('segz', [0])
-        self.is_meter = False
         # Determine the number of segments in z direction
         for i in range(len(self.segz)):
             if self.segz[i] > 0:
@@ -204,78 +217,71 @@ class MagnLoss(Amela):
 
     def periodicity_id(self, b):
         '''identify the periodicity of a given signal'''
-        bx = b['bxl']
-        by = b['byl']
-        idx = bx.shape[1]
+        bxy = np.array(b['bxyl'])
+        npos = bxy.shape[2]
         if self.symmetry:
-            ll = bx.shape[0]
+            nels = bxy.shape[1]
             ff = []
 
-            for i in range(idx):
-                r = idx//(i + 1)
+            for i in range(npos):
+                r = npos//(i + 1)
 
                 if r > 1:
-                    f = 0
-
-                    for j in range(r-1):
-                        f += np.sum(np.abs(bx[:, 0:(i+1)] - bx[:, (j+1)*(i+1)-1:(j+2)*(i+1)-1]))/((i+1)*ll)
-                        f += np.sum(np.abs(by[:, 0:(i+1)] - by[:, (j+1)*(i+1)-1:(j+2)*(i+1)-1]))/((i+1)*ll)
-
-                    ff.append(f/(r-1))
-
+                    ff.append(np.sum([np.sum(
+                        np.abs(bxy[:, :, :(i+1)]
+                               - bxy[:, :, (j+1)*(i+1)-1:(j+2)*(i+1)-1]),
+                        axis=1) / ((i+1)*nels)
+                                      for j in range(r-1)])/(r-1))
             minf = np.amin(ff)
             i = np.argmin(ff)
-            bxymax = np.amax([np.amax(np.abs(bx)), np.amax(np.abs(by))])
+            bxymax = np.amax(np.abs(bxy))
+            logger.debug("ll %d idx %d minf %f i %d bxymax %d",
+                        nels, npos, minf, i, bxymax)
 
             if minf < bxymax * 1e-4:
                 ishift = i
-                num_period = (idx - 1) // ishift
+                num_period = (npos - 1) // ishift
 
                 for j in range(num_period - 1):
-                    bx[:, 0:i+1] += bx[:, i+j*ishift:(i+1)+(j+1)*ishift]
-                    by[:, 0:i+1] += by[:, i+j*ishift:(i+1)+(j+1)*ishift]
+                    bxy[:, :, 0:i+1] += bxy[:, :, i+j*ishift:(i+1)+(j+1)*ishift]
 
-                bx[:, 0:i + 1] /= num_period
-                by[:, 0:i + 1] /= num_period
-                idx = i + 1
+                bxy[:, :, 0:i + 1] /= num_period
+                npos = i + 1
             else:
-                ff = []
-
-                for i in range(idx - 1, 0, -1):
-                    f1 = np.sum(np.abs(bx[:, 0] - bx[:, i]))/ll + np.sum(np.abs(by[:, 0] - by[:, i]))/ll
-                    ff.append(f1)
-
+                ff = [np.sum(np.abs(bxy[:, :, 0] - bxy[:, :, i]))/nels
+                      for i in range(npos - 1, 0, -1)]
                 minf = np.amin(ff)
                 i = np.argmin(ff)
-                idx = idx - i
+                npos = npos - i
 
-        bx_fft = fft(b['bxf'][0:idx-1], (idx-1)/self.tgrid)
-        by_fft = fft(b['byf'][0:idx-1], (idx-1)/self.tgrid)
+        bx_fft = fft(b['bxyf'][0], (npos-1)/self.tgrid)
+        by_fft = fft(b['bxyf'][1], (npos-1)/self.tgrid)
 
         if self.symmetry:
             bxy_amp = bx_fft.amp + by_fft.amp
-            tmp_period = np.array([(idx-1)/i for i in range((idx-1)//2 + 1) if i > 0])
-            idx_nonzero = np.argwhere(tmp_period > 0.1*np.amax(bxy_amp)).squeeze()
-            period = tmp_period[idx_nonzero]
+            tmp_period = np.array([(npos-1)/i
+                                   for i in range((npos-1)//2 + 1) if i > 0])
+            npos_nonzero = np.argwhere(tmp_period > 0.1*np.amax(bxy_amp)).squeeze()
+            period = tmp_period[npos_nonzero]
 
             if np.sum(np.around([period[0]%i for i in period])) == 0:
-                idx = int(np.ceil(np.amax(period))+1)
-                if idx > bx.shape[1]:
-                    idx = bx.shape[1]
-
-        self.tgrid = 60/self.speed*(self.theta[idx-1] - self.theta[0])/360
+                npos = min(int(np.ceil(np.amax(period))+1), bxy.shape[2])
 
-        return [idx, bx_fft, by_fft]
+        try:
+            self.tgrid = 60/self.speed*(self.theta[npos-1] - self.theta[0])/360
+        except AttributeError:
+            self.tgrid = (self.displ[npos-1] - self.displ[0])/self.speed
+        logger.debug("Tgrid %f npos %d bx %f by %f xfreq %s yfreq %s",
+                     self.tgrid, npos-1,
+                     np.max(bx_fft.amp), np.max(by_fft.amp),
+                     bx_fft.freq, by_fft.freq)
+        return [npos, bx_fft, by_fft]
 
     def consider_bx(self, wm, hm, bx_fft, by_fft):
         '''check if a caculation is necessary for the x direction'''
         fft_freq = bx_fft.freq
         fft_freq[fft_freq==0] = 0.5e-2
 
-        if not self.is_meter:
-            self.ls *= 1e-3
-            self.lm *= 1e-3
-            self.is_meter = True
         # skin depth
         delta = self.skin_depth(fft_freq)
 
@@ -296,9 +302,9 @@ class MagnLoss(Amela):
             krfy = dfac(wm/delta)
             py = ampf(by_fft, krfy)*wm**3*hm
 
-        if px/py > 0.005:
-            self.is_x = True
-        return ' '
+        if py > 0:
+            if px/py > 0.005:
+                self.is_x = True
 
     def bpm_fft(self, nx, ny, nt, elxy, bxy):
         '''interpolate the flux density'''
@@ -355,7 +361,7 @@ class MagnLoss(Amela):
             c_ef_n0 = 32/pi**5/eta/dfac(xi)*6
             sum_r = 0.0
             sum_i = 0.0
-            n = np.array([i for i in range(100)])
+            n = np.linspace(100)
             lambda_n = (2*n + 1)*pi
             beta_n = np.sqrt(lambda_n ** 2 + 2j*xi**2)
             beta_nr = np.real(beta_n)
@@ -398,14 +404,16 @@ class MagnLoss(Amela):
                             if self.is_x and nu[ix] < 2:
                                 with warnings.catch_warnings():
                                     warnings.simplefilter('ignore')
-                                    px_se[iy,ix,c] = self.calc_pvpm(bx_fft[iy,ix,c], max(c/self.tgrid, 1e-6),
-                                                                    mu[iy], hm, wm/self.segx[jj], 0)
+                                    px_se[iy,ix,c] = self.calc_pvpm(
+                                        bx_fft[iy,ix,c], max(c/self.tgrid, 1e-6),
+                                        mu[iy], hm, wm/self.segx[jj], 0)
 
                             if mu[iy] < 2:
                                 with warnings.catch_warnings():
                                     warnings.simplefilter('ignore')
-                                    py_se[iy,ix,c] = self.calc_pvpm(by_fft[iy,ix,c], max(c/self.tgrid, 1e-6),
-                                                                    nu[ix], wm/self.segx[jj], hm, 0)
+                                    py_se[iy,ix,c] = self.calc_pvpm(
+                                        by_fft[iy,ix,c], max(c/self.tgrid, 1e-6),
+                                        nu[ix], wm/self.segx[jj], hm, 0)
                 py_sum = np.sum(py_se)
                 px_sum = np.sum(px_se)
                 pec[jj,kk] = (py_sum + px_sum)*(self.ls/self.lm)*self.numpoles*self.segx[jj]
@@ -424,12 +432,10 @@ class MagnLoss(Amela):
             ialh_loss = 0
             loss_detail = []
             for i in k:
-                logger.info(f'magnet width and height: {i["wm"]:.2f}mm {i["hm"]:.2f}mm')
+                logger.info('magnet geom / mm: w %.2f h %.2f l %.2f',
+                            i["wm"]*1e3, i["hm"]*1e3, i["lm"]*1e3)
                 [nt, bx_fft, by_fft] = self.periodicity_id(i['bl'])
                 [nx, ny] = ngrid(i['wm'], i['hm'], i['elcp'])
-                keyset = ('wm', 'hm')
-                for j in keyset:
-                    i[j]*=1e-3
                 self.consider_bx(i['wm'], i['hm'], bx_fft, by_fft)
                 bfft = self.bpm_fft(nx, ny, nt, i['elcp'], i['bl'])
                 loss = self.loss(*bfft, i['wm'], i['hm'])
@@ -483,7 +489,7 @@ class MagnLoss(Amela):
                 for m in range (int(ny/2)):
                     symmetry = 4 if (m > 0) & (n > 0) else 2 # symmetry factor 4 due to double symmetry utilization.
 
-                    for k in range (0,1000,2): # loop is symmetrical on one side
+                    for k in range (0, 1000, 2): # loop is symmetrical on one side
                         complex_xnmkf = sx_ampl[n,m,f]*2/(np.pi*(k+1))*epsilon_z_x/epsilon_z_y*(m*np.pi*wm/hm)/(2j *epsilon**2 + (n*np.pi)**2 + (m*np.pi*wm/hm)**2 + ry*((k+1)*np.pi*wm/lm)**2)
                         complex_ynmkf = sy_ampl[n,m,f]*2/(np.pi*(k+1)) *n*np.pi/(2j *epsilon**2 + (n*np.pi)**2 + (m*np.pi*wm/hm)**2 + rx*((k+1)*np.pi*wm/lm)**2)
                         real_x_nmkf = np.real(complex_xnmkf)
@@ -599,8 +605,8 @@ class MagnLoss(Amela):
                     break
 
             filt = np.ones((nf))
-            for ii in range(ilim,nf):
-                filt[ii] = (feclim/freq[ii])
+            for ii in range(ilim, nf):
+                filt[ii] = feclim/freq[ii]
         for ii in range(nx):       # Derivation in frequency domain
             for jj in range(ny):
                 complbx[ii,jj,:] = -complbx[ii,jj,:]*freq*filt*np.pi*2j
@@ -608,8 +614,8 @@ class MagnLoss(Amela):
 
         for ii in range (nx):       # Inverse Fourier-Transformation
             for jj in range (ny):
-                sx = np.fft.irfftn(complbx[ii,jj,:], [nt - 1])
-                sy = np.fft.irfftn(complby[ii,jj,:], [nt - 1])
+                sx = np.fft.irfftn(complbx[ii,jj,:], s=[nt - 1], axes=[0])
+                sy = np.fft.irfftn(complby[ii,jj,:], s=[nt - 1], axes=[0])
                 sx = np.append(sx, sx[0])
                 sy = np.append(sy, sy[0])
                 sx_pm_3D[ii,jj,:] = sx
@@ -636,25 +642,27 @@ class MagnLoss(Amela):
         '''
         nx_tot = int(nx*nsegx)
         ny_tot = int(ny*nsegy)
-
-        Bxl_ac = np.zeros((np.asarray(bxy['bxl']).shape))
+        bxyl = np.asarray(bxy['bxyl'])
+        Bxl_ac = np.zeros((bxyl[0].shape))
         Byl_ac = np.zeros_like(Bxl_ac)
 
         # Remove the DC component of the original bxl, byl
         for ii in range(Bxl_ac.shape[0]):
-            Bxl_ac[ii,:] = bxy['bxl'][ii,:] - np.mean(bxy['bxl'][ii,:])
+            Bxl_ac[ii,:] = bxyl[0, ii, :] - np.mean(bxyl[0,ii,:])
         for ii in range(Byl_ac.shape[0]):
-            Byl_ac[ii,:] = bxy['byl'][ii,:] - np.mean(bxy['byl'][ii,:])
-
+            Byl_ac[ii,:] = bxyl[1,ii,:] - np.mean(bxyl[1,ii,:])
         xx_ = excpl_new.ravel()
         yy_ = eycpl_new.ravel()
         bx_3d_ac = np.zeros((nx_tot,ny_tot,nt))
         by_3d_ac = np.zeros_like(bx_3d_ac)
 
+        ecpl = elxy['ecpl']
         # Interpolation to the new resolution -> [nx*nsegx, ny*nsegy, nt]
-        by_3d_ac = binterp_ialh2(elxy['excpl'], elxy['eycpl'], xx_, yy_, Byl_ac[:, 0:nt])
+        by_3d_ac = binterp_ialh2(ecpl[0], ecpl[1],
+                                 xx_, yy_, Byl_ac[:, 0:nt])
         if self.is_x:
-            bx_3d_ac = binterp_ialh2(elxy['excpl'], elxy['eycpl'], xx_, yy_, Bxl_ac[:, 0:nt])
+            bx_3d_ac = binterp_ialh2(ecpl[0], ecpl[1],
+                                     xx_, yy_, Bxl_ac[:, 0:nt])
         bx_3d_ac = bx_3d_ac.reshape(nx_tot,ny_tot,nt)
         by_3d_ac = by_3d_ac.reshape(nx_tot,ny_tot,nt)
 
@@ -725,8 +733,10 @@ class MagnLoss(Amela):
         for ii in range(nsegx):
             for jj in range(nsegy):    # nsegy is always = 1
                 for kk in range(nsegz):
-                    Plossx, Plossy = self.ialh2(sx_abs[2*ii*nx:2*(ii+1)*nx, 2*jj*ny:2*(jj+1)*ny,:], sy_abs[2*ii*nx:2*(ii+1)*nx, 2*jj*ny:2*(jj+1)*ny,:],
-                                                sx_phase[2*ii*nx:2*(ii+1)*nx, 2*jj*ny:2*(jj+1)*ny,:], sy_phase[2*ii*nx:2*(ii+1)*nx, 2*jj*ny:2*(jj+1)*ny,:],
+                    Plossx, Plossy = self.ialh2(sx_abs[2*ii*nx:2*(ii+1)*nx, 2*jj*ny:2*(jj+1)*ny,:],
+                                                sy_abs[2*ii*nx:2*(ii+1)*nx, 2*jj*ny:2*(jj+1)*ny,:],
+                                                sx_phase[2*ii*nx:2*(ii+1)*nx, 2*jj*ny:2*(jj+1)*ny,:],
+                                                sy_phase[2*ii*nx:2*(ii+1)*nx, 2*jj*ny:2*(jj+1)*ny,:],
                                                 freq_range, wm/nsegx, hm/nsegy, lm/nsegz, delta_eff)
                     pec[ii,jj,kk] = (Plossx + Plossy)
 
@@ -740,8 +750,8 @@ class MagnLoss(Amela):
         Returns: all_load_cases: list of losses for all load cases
         '''
 
-        nsegx = max(1,nsegx)    #  1 = no segmentation
-        nsegz = max(1,nsegz)    #  1 = no segmentation
+        nsegx = max(1, nsegx)    #  1 = no segmentation
+        nsegz = max(1, nsegz)    #  1 = no segmentation
         nsegy = 1               # y segmentation not supported, nsegy is always = 1
 
         delta_eff = 0
@@ -751,22 +761,28 @@ class MagnLoss(Amela):
             ialh_loss = 0
             loss_detail = []
             for i in k:                 # loop for each superelement in a case
-                logger.info(f'magnet width and height: {i["wm"]:.2f}mm {i["hm"]:.2f}mm')
-                logger.info(f'number of magnet segments: x: {nsegx:.0f} y: {nsegy:.0f} z: {nsegz:.0f}')
-                (nt, bx_fft, by_fft) = self.periodicity_id(i['bl'])             # finds the time periodic part of the simulation
-                (nx, ny, nz, excpl_new, eycpl_new) = Segmentation(i['wm'], i['hm'], i['lm'], i['elcp'], nsegx, nsegy, nsegz)
-                # conversion from mm to m for wm,hm,lm
-                wm = i['wm']/1000
-                hm = i['hm']/1000
-                lm = i['lm']/1000
+                logger.info('magnet geom / mm: w %.2f h %.2f l %.2f segments %s',
+                            i["wm"]*1e3, i["hm"]*1e3, i["lm"]*1e3,
+                            (nsegx, nsegy, nsegz))
+
+                (nt, bx_fft, by_fft) = self.periodicity_id(i['bl'])  # finds the time periodic part of the simulation
+                (nx, ny, nz, excpl_new, eycpl_new) = Segmentation(
+                    i['wm'], i['hm'], i['lm'], i['elcp'],
+                    nsegx, nsegy, nsegz)
+
+                wm = i['wm']
+                hm = i['hm']
+                lm = i['lm']
                 self.consider_bx(wm, hm, bx_fft, by_fft)
-                (sx_abs, sy_abs, sx_phase, sy_phase, freq_range) = self.Process_B_data(nx, ny, nsegx, nsegy, nt, i['elcp'], i['bl'], excpl_new, eycpl_new)
-                loss = self.loss_ialh2(sx_abs, sy_abs, sx_phase, sy_phase, freq_range, nx, ny, wm, hm, lm, nsegx, nsegy, nsegz, delta_eff) * self.numpoles
+                (sx_abs, sy_abs, sx_phase, sy_phase, freq_range) = self.Process_B_data(
+                    nx, ny, nsegx, nsegy, nt, i['elcp'], i['bl'], excpl_new, eycpl_new)
+                loss = self.loss_ialh2(sx_abs, sy_abs, sx_phase, sy_phase, freq_range,
+                                       nx, ny, wm, hm, lm, nsegx, nsegy, nsegz, delta_eff) * self.numpoles
                 ialh_loss += loss
-                logger.info(f'Loadcase {i["loadcase"]}, Superelement {i["spel_key"]}, Total losses =  {loss:.3f} W')
+                logger.info('Loadcase %d, Superelement %s, Total losses =  %.3f W',
+                            i["loadcase"], i["spel_key"], loss)
                 loss_detail.append([i['spel_key'], loss/self.numpoles])
             self.th_loss.append(loss_detail)
             all_load_cases.append(ialh_loss)
 
         return all_load_cases
-