femagtools 1.8.7__py3-none-any.whl → 1.8.9__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):
@@ -1514,7 +1633,7 @@ class SuperElement(BaseEntity):
 
     def get_rect_geom(self):
         """return rectangle parameters of superelement:
-        x0, y0: center coordinates
+        cxy: center coordinates
         w, h: width and height
         alpha: angle of main axis"""
         bxy = np.array([n.xy for b in self.nodechains
@@ -1523,13 +1642,14 @@ class SuperElement(BaseEntity):
         cxy = np.mean(bxy, axis=0)
         # corner points: calculate angles
         b = np.vstack((bxy[-1], bxy, bxy[0]))
-        a = np.arctan2(b[1:, 1]-b[:-1, 1],
-                       b[1:, 0]- b[:-1, 0])
-        peaks = np.where(np.abs(np.diff(a)) > 1)[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
+        # width and height (distances between corners)
         dxy = np.linalg.norm(np.vstack(
-            (bxy[:-1, :] - bxy[1:, :],
+            (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]]),
@@ -1545,7 +1665,7 @@ class SuperElement(BaseEntity):
         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, 'x0': cxy[0], 'y0': cxy[1],
+        return {'w': w, 'h': h, 'cxy': cxy,
                 'area': area, 'alpha': alpha}
 
 

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)
+