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

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
-

femagtools/femag.py

@@ -61,43 +61,6 @@ def handle_process_output(filedes, outfile, log):
                         pass
 
 
-def get_shortCircuit_parameters(bch, nload):
-    try:
-        if nload < 0:
-            nload = 0
-        if nload > 2:
-            nload = 2
-        if nload > 0:
-            dqld = bch.dqPar['ld']
-            dqlq = bch.dqPar['lq']
-            dqpsim = bch.dqPar['psim']
-            if len(dqld) <= nload or len(dqlq) <= nload or len(dqpsim) <= nload:
-                ld = dqld[-1]/bch.armatureLength
-                lq = dqlq[-1]/bch.armatureLength
-                psim = dqpsim[-1]/bch.armatureLength
-            else:
-                ld = dqld[nload-1]/bch.armatureLength
-                lq = dqlq[nload-1]/bch.armatureLength
-                psim = dqpsim[nload-1]/bch.armatureLength
-        else:
-            ld = bch.machine['ld']/bch.armatureLength
-            lq = bch.machine['lq']/bch.armatureLength
-            psim = bch.machine['psim']/bch.armatureLength
-        return dict(
-            r1=bch.machine['r1'],
-            ld=ld,
-            lq=lq,
-            psim=psim,
-            num_pol_pair=bch.machine['p'],
-            fc_radius=bch.machine['fc_radius'],
-            lfe=bch.armatureLength/1e3,
-            pocfilename=bch.machine['pocfile'],
-            num_par_wdgs=bch.machine.get('num_par_wdgs', 0),
-            calculationMode='shortcircuit')
-    except (KeyError, AttributeError, IndexError):
-        raise FemagError("missing pm/Rel-Sim results")
-
-
 def set_magnet_properties(model, simulation, magnets):
     """set temperature adapted magnet properties"""
     if not hasattr(model, 'magnet'):
@@ -449,7 +412,7 @@ class BaseFemag(object):
 
         return list(pathlib.Path(self.workdir).glob('*.PROT'))[0].stem
 
-    def readResult(self, simulation, bch=None):
+    def readResult(self, machine, simulation, bch=None):
         if simulation:
             if simulation['calculationMode'] == "fieldcalc":
                 nc = self.read_nc()
@@ -495,38 +458,11 @@ class BaseFemag(object):
             if simulation['calculationMode'] == 'pm_sym_fast' or \
                 simulation['calculationMode'] == 'torq_calc':
                 if simulation.get('shortCircuit', False):
-                    logger.info("short circuit simulation")
-                    simulation.update(
-                        get_shortCircuit_parameters(bch,
-                                                    simulation.get('initial', 2)))
-
-                    builder = femagtools.fsl.Builder(self.templatedirs)
+                    from .shortcircuit import shortcircuit
                     set_magnet_properties(self.model, simulation, self.magnets)
-                    fslcmds = (builder.open_model(self.model) +
-                               builder.create_shortcircuit(simulation))
-                    fslfile = 'shortcicuit.fsl'
-                    with open(os.path.join(self.workdir, fslfile), 'w') as f:
-                        f.write('\n'.join(fslcmds))
-                    self.run(fslfile) #, options?
-                    bchfile = self.get_bch_file(self.modelname)
-                    if bchfile:
-                        bchsc = femagtools.bch.Reader()
-                        logger.info("Read BCH {}".format(bchfile))
-                        with io.open(bchfile, encoding='latin1',
-                                     errors='ignore') as f:
-                            bchsc.read(f)
-                    bch.scData = bchsc.scData
-                    for w in bch.flux:
-                        try:
-                            bch.flux[w] += bchsc.flux[w]
-                            bch.flux_fft[w] += bchsc.flux_fft[w]
-                        except (KeyError, IndexError):
-                            logging.debug(
-                                "No additional flux data in sc simulation")
-                            break
-
-                    bch.torque += bchsc.torque
-                    bch.demag += bchsc.demag
+                    bch.scData = shortcircuit(self, machine, bch, simulation)
+                    #bch.torque += bchsc.torque
+                    #bch.demag += bchsc.demag
 
             if 'airgap_induc' in simulation:
                 try:
@@ -538,13 +474,15 @@ class BaseFemag(object):
 
             if simulation.get('magnet_loss', False):
                 logger.info('Evaluating magnet losses...')
-                ops = [k for k in range(len(bch.torque))]
-                m = femagtools.ecloss.MagnLoss(self.workdir, self.modelname, ibeta=ops)
+                ops = range(len(bch.torque))
+                ncf = pathlib.Path(self.workdir) / self.modelname
+                m = femagtools.ecloss.MagnLoss(
+                    nc=femagtools.nc.read(ncf), ibeta=ops)
                 try:
                     # change from ialh to ialh2: since v1.8.1
                     magn_losses = m.calc_losses_ialh2()
                 except:
-                    magn_losses = [0 for i in range(len(ops))]
+                    magn_losses = list(range(len(ops)))
 
                 if len(ops) != len(bch.losses):
                     magn_losses.insert(0, magn_losses[0])
@@ -699,8 +637,9 @@ class Femag(BaseFemag):
             setattr(self, "dy2", machine['stator']['dy2'])
         except:
             pass
+
         if simulation:
-            return self.readResult(simulation)
+            return self.readResult(machine, simulation)
 
         return {'status': 'ok', 'message': self.modelname,
                 'model': self.model.props()}
@@ -801,6 +740,7 @@ class ZmqFemag(BaseFemag):
     def subscribe(self, notify):
         """attaches a notify function"""
         logger.info("Subscribe on '%s' port %d", self.femaghost, self.port+1)
+        femagtools.zmq.SubscriberTask.clear()
         if self.subscriber is None:
             # progress/xyplot at a configured timestep published
             header = [b'progress', b'xyplot', b'license']

femagtools/fsl.py

@@ -227,7 +227,7 @@ class Builder:
             #  obsolete
             th_props = [' ']
             try:
-                logger.info(model.magnet)
+                logger.debug(model.magnet)
                 th_props = [f'rotor_density = {model["magnet"]["density"]}',
                             f'rotor_thcond = {model["magnet"]["thcond"]}',
                             f'rotor_thcap = {model["magnet"]["thcap"]}'
@@ -750,12 +750,17 @@ class Builder:
                 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')
+            if sim.get('nload_ex_cur', ''):  # convert obsolete key
+                if isinstance(sim, dict):
+                    sim['noload_ex_cur'] = sim.pop('nload_ex_cur')
+                else:
+                    sim.noload_ex_cur = sim.get('nload_ex_cur')
         felosses = custom_fefunc + self.create_fe_losses(sim)
         fslcalc = (displ_stator_rotor
                    + self.__render(sim, sim.get('calculationMode'))
-                   + airgap_induc + revert_displ)
+                   + airgap_induc + revert_displ
+                   + ['save_model("cont")'])
+
         '''
         if pfefunc:
             sim['loss_funct'] = pfefunc
@@ -768,8 +773,7 @@ class Builder:
                                           'psd_psq_fast'):
             return felosses + fslcalc
 
-        return (felosses + fslcalc +
-                self.__render(sim, 'plots'))
+        return felosses + fslcalc + self.__render(sim, 'plots')
 
     def create_shortcircuit(self, model):
         return self.__render(model, 'shortcircuit')
@@ -832,8 +836,7 @@ class Builder:
         fslmodel = self.create_model(model, magnets, condMat)
         logger.info("create simulation '%s'", sim['calculationMode'])
 
-        return (fslmodel + self.create_analysis(sim) +
-                ['save_model("close")'])
+        return fslmodel + self.create_analysis(sim)
 
     def create_detailed_wire(self, params, templ):
         return self.__render(params, templ)