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

femagtools/isa7.py

@@ -13,6 +13,37 @@ import numpy as np
 logger = logging.getLogger('femagtools.isa7')
 
 
+def Trot(alpha):
+    return np.array([[np.cos(alpha), np.sin(alpha)],
+                     [-np.sin(alpha), np.cos(alpha)]])
+
+def transform_coord(geometry, xy):
+    '''transform from global coord to local coord'''
+    ecpl = Trot(geometry['alpha']).dot((xy-geometry['cxy']).T).T
+    return dict(ecpl=(ecpl + (geometry['w']/2,
+                              geometry['h']/2)).T,
+                ecp=np.asarray(xy).T)
+
+
+def transform_flux_density(alpha, bxy):
+    '''transform the magnet flux density to local coordinate system'''
+    def tf(b1, b2, alpha):
+        if b1.ndim > 1:
+            r = Trot(alpha).dot(((b1.ravel()), (b2.ravel())))
+            return [r[0, :].reshape(*b1.shape),
+                    r[1, :].reshape(*b1.shape)]
+        else:
+            return Trot(alpha).dot(((b1), (b2)))
+
+    b = tf(b1=bxy[:, 0, :], b2=bxy[:, 1, :], alpha=alpha)
+
+    # remove DC component
+    bxf = np.mean(b[0].T - np.mean(b[0], axis=1).T, axis=1)
+    byf = np.mean(b[1].T - np.mean(b[1], axis=1).T, axis=1)
+    return {'bxyl': np.asarray(b),
+            'bxyf': np.array([bxf, byf])}
+
+
 def jordanpfe(Bxnu, Bynu, fnu, losscoeffs, axr):
     """example of custom core loss calculation
     Args:
@@ -72,6 +103,11 @@ class ElType(Enum):
     SquareRectangle = 4
 """Types of elements"""
 
+class MoveType(Enum):
+    Rotate = 0
+    Linear = 1
+"""Types of rotor movement"""
+
 class Reader(object):
     """
     Open and Read I7/ISA7 file
@@ -328,6 +364,7 @@ class Reader(object):
          HI, num_move_ar, self.ANGL_I_UP,
          num_par_wdgs, cur_control) = self.next_block("f")[:8]
         self.NUM_PAR_WDGS = int(num_par_wdgs)
+        self.move_action = move_action  # rotate 0, linear 1
         self.arm_length = arm_length  # unit is m
         self.skip_block(2)
         self.skip_block(30 * 30)
@@ -752,13 +789,14 @@ class Isa7(object):
         self.element_pos = np.array([e.center
                                      for e in self.elements])
 
-        for a in ('FC_RADIUS', 'pole_pairs', 'poles_sim',
+        for a in ('FC_RADIUS', 'pole_pairs', 'poles_sim', 'move_action',
                   'layers', 'coil_span', 'delta_node_angle', 'speed',
                   'MAGN_TEMPERATURE', 'BR_TEMP_COEF',
                   'MA_SPEZ_WEIGHT', 'CU_SPEZ_WEIGHT'):
-            v = getattr(reader, a, '')
-            if v:
-                setattr(self, a, v)
+            try:
+                setattr(self, a, getattr(reader, a))
+            except AttributeError:
+                pass
         if getattr(reader, 'pole_pairs', 0):
             self.num_poles = 2*self.pole_pairs
         if getattr(reader, 'slots', 0):
@@ -771,7 +809,7 @@ class Isa7(object):
 
         self.airgap_inner_elements = [] # used for rotate
         self.airgap_outer_elements = []
-        if hasattr(self, 'FC_RADIUS'):  # Note: cosys r/phi only
+        if getattr(self, 'FC_RADIUS', 0) > 0:  # Note: cosys r/phi only
             # TODO: handle multiple airgaps
             airgap_center_elements = []
             for n in self.nodes:
@@ -1251,13 +1289,94 @@ class Isa7(object):
         try:
             poles_sim = self.poles_sim
         except:
-
             poles_sim = poles
 
         scale_factor = poles/poles_sim
-
         return scale_factor
 
+    def get_magnet_data(self, ibeta=0, icur=0) -> list:
+        '''Extract magnet data from nc file
+
+        Args:
+            nc: nc object
+            icur, ibeta: load case
+
+        Returns:
+          pm_data: list of magnet data
+        '''
+        mag_spels = self.magnet_super_elements()
+        if len(mag_spels) / self.poles_sim == 1:
+            mag_spels = [mag_spels[0]]
+
+        # prepare data for ialh method
+        # conductivity and permeability of the magnets
+        cond = 0
+        mur = 0
+        # read boundary nodes
+        for se in mag_spels:
+            cond = se.conduc
+            if cond <= 0:
+                cond = 625000
+                logging.warning('Magnet conductivity  <= 0, using 625000 S/m')
+            mur = np.abs(1/se.elements[0].reluc[0])
+            logging.debug('Magnet: mur=%s, conductivity=%s', mur, cond)
+
+        # stationary case, no rotation
+        poles = 0
+        try:
+            poles = self.num_poles
+        except AttributeError:
+            pass
+
+        if poles == 0:  # no rotation
+            freq = self.speed
+            time_vec = np.linspace(0, 1/freq, len(self.pos_el_fe_induction))
+            pos = dict(time=time_vec.tolist(),
+                       freq=freq,
+                       t=float(1/freq))
+            # reset num.poles
+            poles = 1
+        else:
+            if self.move_action == 0:
+                phi = self.pos_el_fe_induction*180/np.pi
+                pos = dict(phi=phi,
+                           speed=self.speed)
+            else:
+                pos = dict(displ=self.pos_el_fe_induction,
+                           speed=self.speed)
+        # prep dictionary for the loss calculation
+        pm_data = []
+        for i, se in enumerate(mag_spels):
+            ecp = [e.center for e in se.elements]
+            geometry = se.get_rect_geom()
+
+            bxy = []
+            for e in se.elements:
+                theta = np.arctan2(float(e.center[1]),
+                                   float(e.center[0]))
+                fd = self.flux_density(e, icur, ibeta)
+                bxy.append(Trot(-theta).dot((fd['bx'], fd['by'])))
+            #= np.moveaxis(bxy, 1, 0)
+            pd = dict(name='pm_data_se' + str(se.key),
+                      hm=geometry['h'],
+                      wm=geometry['w'],
+                      lm=self.arm_length,
+                      alpha=geometry['alpha'],
+                      ls=self.arm_length,
+                      sigma=cond,
+                      mur=mur,
+                      loadcase=ibeta,
+                      numpoles=poles,
+                      bl=transform_flux_density(geometry['alpha'],
+                                                np.array(bxy)),
+                      elcp=transform_coord(geometry, ecp),
+                      area=se.area(),
+                      spel_key=se.key)
+            pd.update(pos)
+
+            pm_data.append(pd)
+        return pm_data
+
 
 class Point(object):
     def __init__(self, x, y):
@@ -1418,6 +1537,13 @@ class Element(BaseEntity):
         """return True if the element has lamination properties"""
         return self.reluc != (1.0, 1.0) and self.mag == (0.0, 0.0)
 
+    def remanence(self, temperature=20):
+        """return remanence Brx, Bry at element
+        Arguments:
+          temperature: (float) temperature in °C"""
+        br_temp_corr = 1. + self.br_temp_coef*(temperature - 20.)
+        return self.mag[0]*br_temp_corr, self.mag[1]*br_temp_corr
+
     def demagnetization(self, temperature=20):
         """return demagnetization Hx, Hy of this element"""
         return self.demag_b(self.flux_density(cosys='polar'), temperature)
@@ -1429,9 +1555,9 @@ class Element(BaseEntity):
             # assume polar coordinates of b
             pos = np.arctan2(self.center[1], self.center[0])
             #pos = 0  # cartesian
-            br_temp_corr = 1. + self.br_temp_coef*(temperature - 20.)
-            magn = np.sqrt(self.mag[0]**2 + self.mag[1]**2)*br_temp_corr
-            alfa = np.arctan2(self.mag[1], self.mag[0]) - pos
+            mag = self.remanence(temperature)
+            magn = np.sqrt(mag[0]**2 + mag[1]**2)
+            alfa = np.arctan2(mag[1], mag[0]) - pos
             b1, b2 = b
             bpol = b1 * np.cos(alfa) + b2 * np.sin(alfa)
             reluc = abs(self.reluc[0]) / (4*np.pi*1e-7 * 1000)
@@ -1505,6 +1631,44 @@ class SuperElement(BaseEntity):
         """return area of this superelement"""
         return sum([e.area for e in self.elements])
 
+    def get_rect_geom(self):
+        """return rectangle parameters of superelement:
+        cxy: center coordinates
+        w, h: width and height
+        alpha: angle of main axis"""
+        bxy = np.array([n.xy for b in self.nodechains
+                        for n in b.nodes[:-1]])
+        # center
+        cxy = np.mean(bxy, axis=0)
+        # corner points: calculate angles
+        b = np.vstack((bxy[-1], bxy, bxy[0]))
+        db = np.diff(b, axis=0)
+        a = np.arctan2(db[:, 1], db[:, 0])
+        da = np.abs(np.diff(a))
+        peaks = np.where((da < 6) & (da > 1))[0]
+        c = bxy[peaks]
+        # width and height (distances between corners)
+        dxy = np.linalg.norm(np.vstack(
+            (np.diff(bxy, axis=0),
+             bxy[-1, :] - bxy[0, :])), axis=1)
+        dc = (np.sum(dxy[peaks[0]:peaks[1]]),
+              np.sum(dxy[peaks[1]:peaks[2]]),
+              np.sum(dxy[peaks[2]:peaks[3]]),
+              np.sum(np.hstack(
+                  (dxy[peaks[3]:], dxy[:peaks[0]]))))
+        w = np.mean(np.sort(dc)[-2:])
+        area = self.area()
+        h = area/w
+        # angle of main axis
+        i = np.argmax(dc)
+        c = np.vstack((c, c[0]))
+        alpha = np.arctan2(c[i+1, 1]-c[i, 1], c[i+1, 0]-c[i, 0])
+        if alpha < 0:
+            alpha += np.pi
+        return {'w': w, 'h': h, 'cxy': cxy,
+                'area': area, 'alpha': alpha}
+
+
 class SubRegion(BaseEntity):
     def __init__(self, key, sr_type, color, name, nturns, curdir, wb_key,
                  superelements, nodechains):

femagtools/leakinduc.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+'''Calculate leakage inductances'''
+import numpy as np
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+def end_wdg_leak_ind_round_wires(l_ew, p, q, m, y, taup, w1, layers, num_par_wdgs, slot_height):
+    '''returns end winding leakage inductance per phase per end winding side (DE or NDE)'''
+    mue0 = 4*np.pi*1e-7
+    if layers == 2:
+        lambda_ew = 0.34*q*(1 - 2*y*taup/(np.pi*l_ew*m*q))
+    if layers == 1:
+        lambda_ew = q*(0.67 - 0.43*(taup + slot_height*np.pi/(2*p))/l_ew)
+    L_ew = mue0*2/(p*q)*(w1/num_par_wdgs)**2*l_ew*lambda_ew
+    return L_ew
+
+
+def end_wdg_leak_ind_hairpin_wires(): #TODO
+    L_ew = 0
+    return L_ew
+
+
+#def slot_leakage_inductance_round_wires(p, q, w1, num_par_wdgs, layers):
+#    '''returns slot leakage inductance per phase'''
+#    mue0 = 4*np.pi*1e-7
+#    if layers == 1:
+#        lambda_slot = 0 # tbc
+#    if layers == 2:
+#        t1 = b2/bs
+#        t2 = b1/b2
+#        t12 = b1/b2
+#        kt1 = (4*t1**2 - t1**4 - 4*np.log(t1) -3)/(4*(1 - t1)*(1 - t1**2)**2) if t1 != 1 else 0
+#        kt2 = (4*t2**2 - t2**4 - 4*np.log(t2) - 3)/(4*(1 - t2)*(1 - t2**2)**2) if t2 != 1 else 0
+#        kt12 = (t12**2 - 2*np.log(t12) - 1)/(2*(1 - t12)*(1 - t12**2)) if t12 != 1 else 0
+#        const = 0.1424 + 0.5*np.arcsin(np.sqrt(1 - (bo/b1)**2)) + ho/bo
+#        lambda_t = h2/b2*kt2 + const
+#        lambda_b = h3/bs*kt1 + h2/(b2-b1)*np.log(b2/b1) + const if b2 != b1 else h3/bs*kt1 + const
+#        lambda_tb = h2/b2*kt12 +  const
+#        lambda_slot = lambda_t + lambda_b + lambda_tb
+#    L_slot = mue0*2/(p*q)*(w1/num_par_wdgs)**2*lambda_slot
+#    return L_slot
+
+
+def slot_leak_ind_fea(): #TODO
+    '''returns slot and tooth tip leakage inductance'''
+    # make a single slot model with detailed windings
+    # run current through windings
+    # L_slot = flux / current
+    # scale to get values per phase
+    L_slot = 0
+    return L_slot
+
+
+def harm_leak_ind(E_fft, order_fft, freq, Ia): # needs to be validated
+    '''returns harmonic leakage inductance per phase'''
+    L_harm = []
+    for ii in range(1, len(order_fft)): # skip 1st order
+        L_harm.append(E_fft[ii] / Ia / (2*np.pi*freq*order_fft[ii]))
+
+    return sum(L_harm)
+

femagtools/losscoeffs.py

@@ -20,6 +20,11 @@ def pfe_jordan(f, B, ch, fh, cw, fw, fb, fo, Bo):
 def pfe_steinmetz(f, B, cw, fw, fb, fo, Bo):
     return cw*(f/fo)**fw * (B/Bo)**fb
 
+def pfe_modified_steinmetz(f, B, ch, cw, alpha, beta, fo, Bo):
+    return ch*(f/fo)*(B/Bo)**(alpha + B*beta) + cw*(f/fo)**2*(B/Bo)**2
+
+def wbert(f, b, ch, cw, cx):
+    return (ch + cw*f)*b**2 + cx*f**0.5*b**1.5
 
 def fitsteinmetz(f, B, losses, Bo, fo, alpha0=1.0):
     """fit coeffs of
@@ -56,6 +61,30 @@ def fitsteinmetz(f, B, losses, Bo, fo, alpha0=1.0):
             fbx, y, (1.0, 1.0, 2.0))
     return fitp
 
+def fit_modified_steinmetz(f, B, losses, Bo, fo):
+    """fit coeffs of modifeld steinmetz
+    losses(f,B)=ch*(f/fo)*(B/Bo)**(alpha + B*beta) + cw*(f/fo)**2*(B/Bo)**2
+    returns (ch, cw, alpha, beta)
+    """
+    pfe = losses
+    z = []
+    for i, fx in enumerate(f):
+        if fx:
+            if isinstance(B[0], float):
+                z += [(fx, bx, y)
+                      for bx, y in zip(B, pfe[i])
+                      if y]
+            else:
+                z += [(fx, bx, y)
+                      for bx, y in zip(B[i], pfe[i])
+                      if y]
+
+    fbx = np.array(z).T[0:2]
+    y = np.array(z).T[2]
+    fitp, cov = so.curve_fit(lambda x, ch, cw, alpha, beta: pfe_modified_steinmetz(
+        x[0], x[1], ch, cw, alpha, beta, fo, Bo),
+        fbx, y, (1.0, 1.0, 1.0, 1.0))
+    return fitp
 
 def fitjordan(f, B, losses, Bo, fo):
     """fit coeffs of
@@ -115,9 +144,6 @@ def fit_bertotti(f, B, losses):
         if j > 2:
             v.append(np.array((f[i0:j+i0], bb, y)).T.tolist())
 
-    def wbert(f, b, ch, cw, cx):
-        return (ch + cw*f)*b**2 + cx*f**0.5*b**1.5
-
     z = np.array([b for a in v for b in a]).T
     fbx = z[0:2]
     y = z[2]