femagtools 1.5.1__py3-none-any.whl → 1.5.2__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.5.1'
+__version__ = '1.5.2'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2016-2022 SEMAFOR Informatik & Energie AG'

femagtools/hxy.py

@@ -4,63 +4,95 @@
     ~~~~~~~~~~~~~~
 
     Reading HXY files (EXPERIMENTAL)
-
+    Build cluster of magnets
 """
 
 import numpy as np
-from collections import defaultdict
+import logging
 
 # K-means clustering
+# https://dev.to/sajal2692/coding-k-means-clustering-using-python-and-numpy-fg1
+# Sajal Sharma
+# with adaptions by Ronald Tanner
+def initialize_random_centroids(K, X):
+    """Initializes and returns k random centroids"""
+    m, n = np.shape(X)
+    # a centroid should be of shape (1, n), so the centroids array will be of shape (K, n)
+    centroids = np.empty((K, n))
+    for i in range(K):
+        # pick a random data point from X as the centroid
+        centroids[i] = X[np.random.choice(range(m))]
+    return centroids
+
+
+def initialize_centroids(K, X):
+    """Initializes and returns k centroids"""
+    c = np.mean(X, axis=0)
+    if K < 2:
+        return [c]
+    alfa = np.arctan2(c[1], c[0])  # angle of center axis
+    T = np.array([[np.cos(alfa), -np.sin(alfa)],
+                  [np.sin(alfa), np.cos(alfa)]])
+    p = (np.asarray(X)-c).dot(T) # rotate X
+    d = np.linalg.norm(p, axis=1) # distance to center
+    a = np.arctan2(p[:, 1], p[:, 0]) # angle to center
+    h, b = np.histogram(a, bins=K)
+    return [np.mean(X[(a>r[0]) & (a<r[1])], axis=0)
+            for r in np.array((b[:-1], b[1:])).T]
+
+
+def closest_centroid(x, centroids, K):
+    """Finds and returns the index of the closest centroid for a given vector x"""
+    distances = np.empty(K)
+    for i in range(K):
+        distances[i] = np.linalg.norm(centroids[i] - x)
+    return np.argmin(distances) # return the index of the lowest distance
+
+
+def create_clusters(centroids, K, X):
+    """Returns an array of cluster indices for all the data samples"""
+    m, _ = np.shape(X)
+    cluster_idx = np.empty(m, dtype=int)
+    for i in range(m):
+        cluster_idx[i] = closest_centroid(X[i], centroids, K)
+    return cluster_idx
+
+
+def compute_means(cluster_idx, K, X):
+    """Computes and returns the new centroids of the clusters"""
+    _, n = np.shape(X)
+    centroids = np.empty((K, n))
+    for i in range(K):
+        points = X[cluster_idx == i]  # gather points for the cluster i
+        centroids[i] = np.mean(points, axis=0) # use axis=0 to compute means across points
+    return centroids
+
+
+def run_Kmeans(K, X, max_iterations=500):
+    """Runs the K-means algorithm and computes the final clusters"""
+    # initialize centroids
+    centroids = initialize_centroids(K, X)
+    # loop till max_iterations or convergance
+    logging.debug(f"initial centroids: {centroids}")
+    for _ in range(max_iterations):
+        # create clusters by assigning the samples to the closet centroids
+        clusters = create_clusters(centroids, K, X)
+        previous_centroids = centroids
+        # compute means of the clusters and assign to centroids
+        centroids = compute_means(clusters, K, X)
+        # if the new_centroids are the same as the old centroids, return clusters
+        diff = previous_centroids - centroids
+        if not diff.any():
+            return clusters
+    return clusters
+
+"""references properties i to magnet k"""
 class point():
     def __init__(self, index, k, coord):
         self.index = index
         self.coord = coord
         self.k = k
 
-def make_k_mapping(points):
-    region = defaultdict(list)
-    for p in points:
-        region[p.k] = region[p.k] + [p.coord]
-    return region
-
-def calc_k_means(region):
-    return [np.mean(region[k], axis=0) for k in region]
-
-def update_k(points, means):
-    for p in points:
-        dists = [np.linalg.norm(m - p.coord) for m in means]
-        p.k = np.argmin(dists)
-
-def fit(points, epochs=10):
-    for e in range(epochs):
-        region = make_k_mapping(points)
-        means = calc_k_means(region)
-        update_k(points, means)
-    return means, points
-
-def evaluate(points):
-    region = make_k_mapping(points)
-    means = calc_k_means(region)
-    dists = [np.linalg.norm(means[p.k]-p.coord) for p in points]
-    return np.mean(dists)
-
-def llf_(y, X, pr):
-    # return maximized log likelihood
-    nobs = float(X.shape[0])
-    nobs2 = nobs / 2.0
-    nobs = float(nobs)
-    resid = y - pr
-    ssr = np.sum((resid)**2)
-    llf = -nobs2*np.log(2*np.pi) - nobs2*np.log(ssr / nobs) - nobs2
-    return llf
-
-
-def aic(y, X, pr, p):
-    # return aic metric
-    llf = llf_(y, X, pr)
-    return -2*llf+2*p
-
-
 def readSections(f):
     section = []
     movepos = False
@@ -83,44 +115,67 @@ def readSections(f):
 
 
 def read(filename, num_magnets):
-    """read hxy file and return values grouped to magnets"""
+    """read hxy file and return values grouped to magnets
+    returns:
+      list of m=num_magnets dicts
+        pos: list of n positions in degree
+        e: n lists of center coordinates of elements in m
+        hxy: n lists of field strengths in kA/m
+        bxy: n lists of flux densities in T
+        mxy: n lists of magnetization in T
+        havg: average of field strengths kA/m
+        hmax: maximum of field strengths kA/m
+    """
     hxy = []
     with open(filename, encoding='latin1', errors='ignore') as f:
+        n = 0
+        k = 0
         for s in readSections(f):
             pos = float(s[0].split()[-1])
             num = np.array([[float(x) for x in l.split()] for l in s[5:] if l])
             hxy.append({'pos': pos, 'e': num[:, :2], 'hxy': num[:, 2:4],
                         'bxy': num[:, 4:6], 'mxy':num[:, 6:]})
+            logging.info("HXY Section %d: pos %f shape %s", n, pos, num.shape)
+            n += 1
+            if k == 0:
+                k = num.shape[1]
         K = num_magnets
-        points = [point(i, np.random.randint(0,K), xy)
-                  for i, xy in enumerate(hxy[0]['e'])]
-        new_means, new_points = fit(points)
+        y_preds = run_Kmeans(num_magnets, np.array(hxy[0]['e']))
+        logging.info("Kmeans: %s",
+                     [y_preds[y_preds==k].shape[0] for k in range(K)])
+        points = [point(i, k, hxy[0]['e'][i]) for i, k in enumerate(y_preds)]
         # move values to magnets:
-        magnets = [{'e': [p.coord for p in new_points if p.k == k],
-                    'pos': [], 'hxy': [], 'bxy': [], 'mxy': []}
+        magnets = [{'e': [[h['e'][p.index]*1e-3
+                           for p in points if p.k == k]
+                    for h in hxy]}
                    for k in range(K)]
-        hkeys = ['hxy', 'bxy', 'mxy']
-        for i, h in enumerate(hxy):  # all positions
-            for mag in magnets:
-                mag['pos'].append(h['pos'])
-                m = [{k: [] for k in hkeys}
-                     for kk in range(K)]
-            for p in new_points:  # all elements
-                for k in hkeys:
-                    m[p.k][k].append(h[k][p.k])
-            for mk, magk in zip(m, magnets):
-                for k in hkeys:
-                    magk[k].append(mk[k])
-        for mag in magnets:
-            for k in ['e'] + hkeys:
-                mag[k] = np.array(mag[k])
-            mag['havg'] = []
-            mag['hmax'] = []
-            for hpos in mag['hxy']:
-                h = np.abs(np.linalg.norm(hpos, axis=1))
-                mag['havg'].append(np.mean(h))
-                mag['hmax'].append(np.max(h))
-
-        # Note dimension of hkeys is (positions x elements x 2)
+
+        for k, mag in enumerate(magnets):
+            mag['pos'] = [h['pos'] for h in hxy]
+            for mk in ['hxy', 'bxy', 'mxy']:
+                mag[mk] = [[h[mk][p.index] for p in points if p.k == k]
+                           for h in hxy]
+            hxyabs = [np.linalg.norm(hxy, axis=1)
+                      for hxy in mag['hxy']]
+            mag['havg'] = [np.mean(a) for a in hxyabs]
+            mag['hmax'] = [np.max(a) for a in hxyabs]
 
     return magnets
+
+if __name__ == '__main__':
+    import sys
+    import matplotlib.pyplot as plt
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s %(message)s')
+    magnets = read(sys.argv[1], int(sys.argv[2]))
+    for m in magnets:
+        print(f"{len(m['e'][0])}: Havg {m['havg']} Hmax {m['hmax']}")
+
+    fig, ax = plt.subplots()
+    for m in magnets:
+        b = np.array(m['e'][0])
+        ax.scatter(*b.T)
+    ax.set_aspect('equal')
+    ax.autoscale(enable=True)
+    ax.axis('off')
+    plt.show()

femagtools/machine/afpm.py

@@ -11,8 +11,9 @@ from .. import model
 from .. import utils
 from .. import windings
 from .. import femag
-from scipy.interpolate import RegularGridInterpolator, interp1d
+from scipy.interpolate import RegularGridInterpolator, interp1d, RectBivariateSpline
 from scipy.integrate import quad
+import copy
 
 logger = logging.getLogger(__name__)
 
@@ -38,6 +39,50 @@ def _integrate1d(radius, val):
         return interp((x))
     return quad(func, radius[0], radius[-1])[0]
 
+def ld_interpol(i1, beta, v):
+    '''interpolate Ld at beta angle 0°, -180°'''
+    # ld
+    cur = copy.deepcopy(i1)
+    betad = copy.deepcopy(beta)
+    if np.amin(beta) < -90 and \
+        np.amax(beta) > -90: 
+        # motor and generator
+        v[0] = v[1]
+        v[-1] = v[-2]
+
+        dbeta = np.abs(beta[0][0] - beta[1][0])
+        bp = [[beta[0][0]-dbeta for i in range(len(np.unique(i1)))]] + beta[1:-1] + \
+            [[dbeta for i in range(len(np.unique(i1)))]]
+    else: 
+        v[-1] = v[-2]
+        dbeta = np.abs(beta[0][0] - beta[1][0])
+        bp = beta[0:-1] + \
+            [[dbeta for i in range(len(np.unique(i1)))]]
+    
+    return RectBivariateSpline(np.unique(bp), np.unique(cur), \
+         np.array(v)).ev(*[betad, i1]).tolist()
+
+def lq_interpol(i1, beta, v):
+    '''interpolate Lq at beta -90°'''
+    if -90 not in np.unique(beta): 
+        return v
+    # lq
+    betad = copy.deepcopy(beta)
+    if np.amin(beta) < -90 and \
+        np.amax(beta) > -90:
+        # motor and generator
+        inx = np.argwhere(np.array(beta) == -90).squeeze()
+        v.pop(inx[0, 0])
+        bp = beta[0:inx[0, 0]] + beta[inx[0, 0]+1:]
+        cp = i1[0:inx[0, 0]] + i1[inx[0, 0]+1:]
+    else: 
+        v[0] = v[1]
+        dbeta = np.abs(beta[0][0] - beta[1][0])
+        bp = [[-90-dbeta for i in i1[0]]] + beta[1::]
+        cp = i1
+    cur = copy.deepcopy(cp)
+    return RectBivariateSpline(np.unique(bp), np.unique(cur), \
+         np.array(v)).ev(*[betad, i1]).tolist()
 
 def parident(workdir, engine, temp, machine,
              magnetizingCurves, magnetMat=[], condMat=[],
@@ -243,6 +288,29 @@ def parident(workdir, engine, temp, machine,
                           (-1, num_beta_steps)).T/np.sqrt(2)
         psiq = np.reshape([r['psiq'] for r in postp],
                           (-1, num_beta_steps)).T/np.sqrt(2)
+        
+        ld = np.reshape([r['Ld'] for r in postp],
+                          (-1, num_beta_steps)).T.tolist()
+        lq = np.reshape([r['Lq'] for r in postp],
+                          (-1, num_beta_steps)).T.tolist()
+        # interpolation ld, lq
+        curr, angl = [], [] 
+        for cr in range(len(beta)): 
+            curr.append(i1)
+        for al in beta: 
+            tmp = []
+            for cr in range(len(i1)): 
+                tmp.append(al)
+            angl.append(tmp)
+        try:
+            xx, yy = copy.deepcopy(curr), copy.deepcopy(angl)
+            ld = ld_interpol(xx, yy, ld)
+            xx, yy = copy.deepcopy(curr), copy.deepcopy(angl)
+            lq = lq_interpol(xx, yy, lq)
+        except: 
+            ld = np.zeros_like(psid).tolist()
+            lq = np.zeros_like(psid).tolist()
+        
         torque = np.reshape([r['torque'] for r in postp],
                             (-1, num_beta_steps)).T
         losses = {k: np.flip(np.reshape([r['plfe'][k] for r in postp],
@@ -259,6 +327,7 @@ def parident(workdir, engine, temp, machine,
         ldq.append({'temperature': magtemp,
                     'i1':i1, 'beta':beta,
                     'psid': psid.tolist(), 'psiq': psiq.tolist(),
+                    'ld': ld, 'lq': lq,
                     'torque': torque.tolist(),
                     'losses': losses})
         # T = 3/2 p (Psid iq - Psiq id)

femagtools/machine/sizing.py

@@ -736,8 +736,10 @@ def im(pnom: float, speed: float, p: int, **kwargs) -> dict:
         slots = []
     r = get_stator_dimensions(par, slots=slots)
     # rotor parameters
+    rtype = kwargs.get('rtype', 'rotorKs2')
     r['rotor'] = get_im_rotor_dimensions(
-        par['cos_phi']*r['A'], r['Da2'], r['psi1'], r['lfe'], par)
+        par['cos_phi']*r['A'], r['Da2'], r['psi1'], r['lfe'],
+        par, rtype=rtype)
     _set_genpars(r, 2*par['p'])
     r['name'] = f"IM-{r['poles']}"
     return r

femagtools/machine/utils.py

@@ -350,21 +350,27 @@ def dqparident(workdir, engine, temp, machine,
     """
     import pathlib
 
-    da1 = machine['outer_diam']
+    wdgk = 'windings' if 'windings' in machine else 'winding'
+    da1 = machine['bore_diam']
     Q1 = machine['stator']['num_slots']
+    lfe = machine['lfe']
+    g = machine[wdgk].get('num_par_wdgs', 1)
     slotmodel = [k for k in machine['stator'] if isinstance(
         machine['stator'][k], dict)][-1]
     if slotmodel == 'stator1':
         hs = machine['stator']['stator1']['slot_rf1'] - \
             machine['stator']['stator1']['tip_rh1']
     else:
-        hs = machine['stator'][slotmodel].get('slot_height', 0)
-    wdgk = 'windings' if 'windings' in machine else 'winding'
+        dy1 = machine['outer_diam']
+        hs = machine['stator'][slotmodel].get(
+            'slot_height', 0.6*(dy1-da1)/2)
+
     N = machine[wdgk]['num_wires']
-    Jmax = 15  # max current density in A/mm2
+    Jmax = 20e6  # max current density in A/m2
+    f = machine[wdgk].get('fillfac', 0.42)
+    Acu = f*0.5*np.pi*(da1+hs)*hs
+    i1_max = round(Acu/Q1/N*Jmax/10)*10
 
-    i1_max = round(0.28*np.pi*hs*(da1+hs)/Q1/N*Jmax*1e5)*10 * \
-        machine[wdgk].get('num_par_wdgs', 1)
     period_frac = kwargs.get('period_frac', 6)
     if machine.get('external_rotor', False):
         period_frac = 1  # TODO: missing femag support
@@ -381,8 +387,6 @@ def dqparident(workdir, engine, temp, machine,
 
     wdg = windings.Winding(wpar)
 
-    lfe = machine['lfe']
-    g = machine[wdgk].get('num_par_wdgs', 1)
     if 'wire_gauge' in machine[wdgk]:
         aw = machine[wdgk]['wire_gauge']
     elif 'dia_wire' in machine[wdgk]:

femagtools/plot/nc.py

@@ -84,17 +84,16 @@ def _contour(ax, title, elements, values, label='',
                                   for n in nc.nodes],
                                  color='gray', alpha=0.1, lw=0))
     valid_values = np.logical_not(np.isnan(values))
-    patches = np.array([Polygon([v.xy for v in e.vertices])
-                       for e in elements])[valid_values]
+    vertices = [[v.xy for v in e.vertices] for e in elements]
+    patches = np.array([Polygon(xy) for xy in vertices])[valid_values]
     p = PatchCollection(patches, match_original=False,
                         cmap=cmap, alpha=alpha)
     p.set_array(np.asarray(values)[valid_values])
     ax.add_collection(p)
     cb = plt.colorbar(p, shrink=0.9)
 
-    for patch in np.array([Polygon([v.xy for v in e.vertices],
-                                   fc='white', alpha=1.0)
-                           for e in elements])[np.isnan(values)]:
+    for patch in np.array([Polygon(xy, fc='white', alpha=1.0)
+                           for xy in vertices])[np.isnan(values)]:
         ax.add_patch(patch)
     if label:
         cb.set_label(label=label)
@@ -135,9 +134,10 @@ def demag_pos(isa, pos=-1, icur=-1, ibeta=-1, cmap=DEFAULT_CMAP, ax=0):
         x = isa.pos_el_fe_induction[i]
 
     hpol = demag[:, i]
+    hmax = np.max(hpol)
     hpol[hpol == 0] = np.nan
-    _contour(ax, f'Demagnetization at pos. {round(x/np.pi*180):.1f}°,'
-    f'{isa.MAGN_TEMPERATURE} °C (max -{np.max(hpol):.1f} kA/m)',
+    _contour(ax, f'Demagnetization at pos. {round(x/np.pi*180):.1f}°, '
+    f'{isa.MAGN_TEMPERATURE} °C (max -{hmax:.1f} kA/m)',
              emag, hpol, '-H / kA/m', cmap, isa)
     logger.info("Max demagnetization %f kA/m", np.nanmax(hpol))
 

femagtools/vtu.py

@@ -1,9 +1,11 @@
 """Read FEMAG vtu files
 
 """
-import vtk
+import logging
 import pathlib
 import numpy as np
+import vtk
+from vtkmodules.util.numpy_support import vtk_to_numpy
 
 
 class Reader(object):
@@ -23,11 +25,13 @@ class Reader(object):
         self.field_data_names = []
         self.point_data_names = []
         self.cell_data_names = []
+        assert pathlib.Path(pathname).exists(), f"{pathname} not found"
         if pathlib.Path(pathname).suffix == '.vtu':
             self.filenames = [pathlib.Path(pathname)]
         else:
             self.filenames = sorted(pathlib.Path(pathname).glob(
                 "*.vtu"))
+
         self.reader.SetFileName(str(self.filenames[0]))
         self.reader.Update()
         self.field_data_names = [
@@ -181,7 +185,7 @@ class Reader(object):
             point_vec.append(self.data[pnt_data][i].GetValue(pnt-1))
         return point_vec
 
-    def get_cell_vector(self, cell_data, cell) -> list:
+    def get_cell_vector(self, cell_data, cell=0) -> list:
         '''Read cell data
 
         Args:
@@ -195,6 +199,9 @@ class Reader(object):
         if cell_data not in self.data:
             self.read_data([cell_data])
 
+        if cell<=0:
+            return vtk_to_numpy(
+                self.output.GetCellData().GetAbstractArray(cell_data))
         i = self.cell_data_names.index(cell_data)
         noc = self.output.GetCellData().GetAbstractArray(i).GetNumberOfComponents()
         if noc == 1:
@@ -228,12 +235,64 @@ class Reader(object):
         else:
             return [cell_vec_x, cell_vec_y, cell_vec_z]
 
+    def hrphi(self, scf, elements, magtemp):
+        """return H values for each element in polar coord system
+        (experimental)
+        Args:
+          elements: list of model elements
+          magtemp: magnet temperature in degree Celsius
+          scf: scale factor (poles/poles in model)
+        """
+        MUE0 = 4e-7*np.pi
+        b = vtk_to_numpy(
+            self.output.GetCellData().GetAbstractArray("b"))[:, :2]
+        e = elements[0]
+        x, y = np.mean(vtk_to_numpy(
+            self.output.GetCell(e.key-1).GetPoints().GetData()), axis=0)[:2]
+        rotpos = np.arctan2(y, x) - np.arctan2(e.center[1], e.center[0])
+        psign = 1 if rotpos / scf > 1 else -1
+
+        h = np.empty((len(elements), 2))
+        for i, e in enumerate(elements):
+            x, y = e.center
+            alfa = np.arctan2(y, x)
+            b1, b2 = b[e.key-1]
+            btempc = 1. + e.br_temp_coef*(magtemp - 20.)
+            m1 = e.mag[0]*np.cos(alfa) + e.mag[1]*np.sin(alfa)
+            m2 = -e.mag[0]*np.sin(alfa) + e.mag[1]*np.cos(alfa)
+            h[i] = abs(e.reluc[0])/MUE0*np.array((
+                (b1 - psign*btempc*m1), (b2 - psign*btempc*m2)))
+        logging.debug("H shape %s", h.shape)
+        return h
+
+
+    def demag(self, elements):
+        """return demag values for each element in kA/m
+        Args:
+          elements: list of model elements
+        Returns:
+          list of demags from each vtu file in set
+        """
+        dlist = []
+        for filename in self.filenames:
+            self.reader.SetFileName(str(filename))
+            self.reader.Update()
+            d = vtk_to_numpy(
+                self.output.GetCellData().GetAbstractArray("demagnetization"))
+            dm = np.empty((len(elements)))
+            for i, e in enumerate(elements):
+                dm[i] = d[e.key-1]
+            dlist.append(dm)
+        logging.debug("Demag shape %s", np.array(dlist).shape)
+        return dlist
+
+
     def get_data_vector(self, data_name, key=0) -> list:
         '''Read data of fiels, point or cell
 
         Args:
           data_name : str Name of data to read
-        hey : int (optional) Key of point or cell
+          key : int (optional) Key of point or cell
 
         Returns:
             List of values within the time window
@@ -246,6 +305,16 @@ class Reader(object):
             return self.get_cell_vector(data_name, key)
         return []
 
+    def __repr__(self):
+        fmt = [f"N Cells {self.output.GetNumberOfCells()}  N Points {self.output.GetNumberOfPoints()}"]
+        fmt += [
+            f"{self.output.GetPointData().GetAbstractArray(i).GetName()}   Points"
+            for i in range(self.output.GetPointData().GetNumberOfArrays())]
+        fmt += [
+            f"{self.output.GetCellData().GetAbstractArray(i).GetName()}   Cells"
+            for i in range(self.output.GetCellData().GetNumberOfArrays())]
+        return '\n'.join(fmt)
+
 
 def read(filename) -> Reader:
     """

{femagtools-1.5.1.dist-info → femagtools-1.5.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: femagtools
-Version: 1.5.1
+Version: 1.5.2
 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.5.1.dist-info → femagtools-1.5.2.dist-info}/RECORD

@@ -1,4 +1,4 @@
-femagtools/__init__.py,sha256=WYCiO3Ceu0xELGYtZqE4IhrBuyn7Rm1wM0fZqs7sgaU,1615
+femagtools/__init__.py,sha256=kGZSfjN0Y6_CwYhVU9ki2misQXnylS2nmIQNI60q1lk,1615
 femagtools/airgap.py,sha256=s8NoKFvBhkINxkMLG02RbLZA9PiSx9KMtPjByy1WwNc,1584
 femagtools/amazon.py,sha256=O1ICuv21XDAJi1qK1Sigs2TdS6hDZP19OzvmE2t76wU,12069
 femagtools/amela.py,sha256=pHjfXzpANI-7oz8MtrqNcyDZ6PxVM91vCJuvYhHy1rk,13891
@@ -22,7 +22,7 @@ femagtools/getset.py,sha256=yJ6Em35DeWK7WNZW0qjjS5s7LUkVh5mbgxF59HHm5FM,3017
 femagtools/gmsh.py,sha256=IKhNiviIBji4cMxAhxaYXNqBRMNAPSKsBGdnGyxkyQw,3903
 femagtools/google.py,sha256=ugRyHY1zBjHR4aNfbA7GeF-ZU_NgleuVTZaWpi_XLT4,17144
 femagtools/grid.py,sha256=s7LfKKLm2H4-cza2kSEANq6vwxq10Su3TJl3kHShHRA,1561
-femagtools/hxy.py,sha256=TU0GoHtStq3VBoc4nGLmtKquY8-tT0UWxLf5FzMBLjE,3738
+femagtools/hxy.py,sha256=PkiZ_-CRhtvtpkmLAP8iMtwvzh7CjKGGcAbOhFb4Nls,6275
 femagtools/isa7.py,sha256=KDZcakwRdlC8KECpQKoFzI-L2ZILJSaUp_MNOZNOfoE,57374
 femagtools/jhb.py,sha256=stJxkmzHpfUIBVcFw7jWbV5KN9_EFqzOCgacyhUqWvM,1779
 femagtools/job.py,sha256=dOatzr10nIda76CjVRSS0SfEWC8_BAw0kowli523qbY,11320
@@ -44,7 +44,7 @@ femagtools/tks.py,sha256=FuEKiWcSnOW2Hp2NxCq1hBeQdRFkHutaJuctrhxh8Ws,6228
 femagtools/ts.py,sha256=JZbiXhss6f5J8gDhOMmfZe-fkroBA1BRcpGE5PGZjWU,47175
 femagtools/utils.py,sha256=Pi-FeM81Fm0m3GF1Mq9EYcTNeW_BI6qIXVGhbYcC1cY,1434
 femagtools/vbf.py,sha256=9XGfhftmD9carU8ByQ5DwqoR4daq5mJ39eMqruwml0Q,2444
-femagtools/vtu.py,sha256=NhbwGGGeRDhvNWA58z-Npm7nylvfOzZcaYtfHHWWjqE,8000
+femagtools/vtu.py,sha256=Sf83dHIfCKY2km-MIUHKKoj-JKN4PDX7kkPLZXyIYY4,10723
 femagtools/windings.py,sha256=6ioABZRWQ3xA4kmEz2NUkXh-C-FmW9YYkjQKs5YakQs,22197
 femagtools/dxfsl/__init__.py,sha256=MywcCdpKPKs4qJBJJgeDsikJFJ2P48dbTuNk303f5pM,76
 femagtools/dxfsl/area.py,sha256=3YSa6tNW1vToZiUuo-0cghxtYG0jzIOU91dEibueltE,55787
@@ -59,13 +59,13 @@ femagtools/dxfsl/machine.py,sha256=E2w1vduaRn1yWfp6cQtvN4Rf0AeJWqbHNtOF5YofeEI,3
 femagtools/dxfsl/plotrenderer.py,sha256=lJFEH0Jdsph3atcABMS6IweKNPANxJA1aF0YlMdk_p0,12725
 femagtools/dxfsl/shape.py,sha256=BYIePcfpSPLgE5DjwTs5ofQbuIF4MdTvCitwrvNQiw4,46010
 femagtools/machine/__init__.py,sha256=m3DnYBP8Wxh-qDoFhkPVlXUGcA4fjDOVleqo3YQ4syA,7728
-femagtools/machine/afpm.py,sha256=QqYs9Qpxmb10UbaLJ1cvNZBIdUgFUTPHtrwNMu63imI,22417
+femagtools/machine/afpm.py,sha256=TRRGKZWpbXWPXMJQPXAjfOtmXm1XPCnwgzhgBjexfl8,24813
 femagtools/machine/effloss.py,sha256=aaSmmxKd_KWMasHUHipYDcZOw-fvTHNa38MWFnpVock,13130
 femagtools/machine/im.py,sha256=ScIOLrlc4CPLYFNx2MmJqkpmbky_HXxFGZbMWUNGBrk,37881
 femagtools/machine/pm.py,sha256=suVFbQ8E8winWaoSQOYnA3Qggn_8ObQVS7mjigwO3Ig,53319
-femagtools/machine/sizing.py,sha256=BNaYNmZpOz-Q8grCara_hTeen5rbRPqpNcnLr84W9o4,23031
+femagtools/machine/sizing.py,sha256=aN_OahewjTTBHnpRNfLh1AGFhqnoeZVuMBeb_3MCIVI,23096
 femagtools/machine/sm.py,sha256=iiFBLmMliDvx3rdKscU7XZLu0TK66F__BA5S7JlbR-8,32958
-femagtools/machine/utils.py,sha256=oqGE_q1uDZYR6cqo2TPNBh6gw8wBT_TfUlv9QB1FVxo,16698
+femagtools/machine/utils.py,sha256=i2nnwYLTrf_OZbSDgo6uhHpH8-7UaWlRbvgp_BL4JSE,16770
 femagtools/moo/__init__.py,sha256=zinmWEOrsEz6DmMX0Dbn4t6_1UR-p4bEGqyR1wUQk_Q,175
 femagtools/moo/algorithm.py,sha256=lNEf0Bur4yFpIJeLtAC3oIus8sOMWTb7jepFlD28YzE,5445
 femagtools/moo/population.py,sha256=gi8PSVUXkYY5vzgAwWvxfMbH_z51fN58O4-NKoarwzI,10100
@@ -79,7 +79,7 @@ femagtools/plot/char.py,sha256=pfmsoSbrE4QuWBaGV9X7s2hT4OSK5ZQ99drmE4y1TDw,11192
 femagtools/plot/fluxdens.py,sha256=NlexRJ3f_8CgKoWrV82ZIsAXPrLhwj98uOe8_fUks7A,1082
 femagtools/plot/forcedens.py,sha256=37FQLViGsjCh20tSlWlVfLTsvtjzdK_pEQGC2KcQ-xI,2996
 femagtools/plot/mcv.py,sha256=AKbWhJd20Kcec8Hv9dX32G5yTLPkcWorQS7-3P6m-mQ,2960
-femagtools/plot/nc.py,sha256=iHU7gb31Hm-se_ArPQqTpJjhPzjraYZN7OKN79hF3Aw,9541
+femagtools/plot/nc.py,sha256=CU-6420EYq6S4ZzyqxCOyxrbHIeJ8_aBVxDPM3E2oD4,9516
 femagtools/plot/phasor.py,sha256=5iqxCQi_idkdqYALJjQb6YFr_Zv5xsUayDoKL5HzsdE,4765
 femagtools/plot/wdg.py,sha256=UooR1K8JDoVjKWEox_AfkBY40L87jk2L9OdIFz4O-OY,8462
 femagtools/templates/FE-losses.mako,sha256=Rql5_8Q6_uthpr-uFXMUo7tdHehfZYND-7M-ohJXVU8,874
@@ -162,6 +162,7 @@ tests/test_erg.py,sha256=kRVzpXa6JDdbxTss18HUWKny9Dx8IMx9uGTrbQCnHwg,523
 tests/test_femag.py,sha256=l7-av3eitLm7bwTuunEmVeTspi82ifPrlz7f1boGdVI,1934
 tests/test_forcedens.py,sha256=Yzl3SAmJNkZN9dA3aLxRvwY8fKsw077Fl0iJm6zJ5Sk,536
 tests/test_fsl.py,sha256=I2UqfZgvm5J2kc8sRlDiQY9MH6wIjBmLLx0i-fYqYYA,16623
+tests/test_hxy.py,sha256=pVb6ZfDhBy5-DXa3gh7RQmLFG8p5cSYB8gdGLC8kjAk,640
 tests/test_im.py,sha256=55wfCoA8_PuogI_RsC3AjUQCpR84T-HddtHuU1NxfPc,662
 tests/test_isa7.py,sha256=GJhRj2nncrUpNTIlM4jvG4kKZS7cK19hhQg9KbM3b5Q,3001
 tests/test_jhb.py,sha256=aDzwr2ZaXlizrPnlLlcI_IT3OpSxuKu-FzBBkIALEDg,824
@@ -179,12 +180,12 @@ tests/test_nc.py,sha256=aQNHHDBnyr1mV8yfaBh728tjDkRn3DLUgEaYV5GtBYE,4205
 tests/test_parident.py,sha256=RiEEdRjR6SVebdxPMwkT0FMt7MlHXCfxChHpbAo5reI,1340
 tests/test_parstudy.py,sha256=wk7WfYQrx5dtv6MnmWCfNAEInvRKsbVXYEUIIR9zLbQ,3200
 tests/test_pocfile.py,sha256=eiMLBRQxDnHIGiqku6EXcQ3fb7wGIxhXmb20iyLlPRU,5816
-tests/test_sizing.py,sha256=UEZV0wLNQhzcXVO1ysfQNXdX-fNIEM98Ya8zFw6gFf8,1109
+tests/test_sizing.py,sha256=8tIT8DG1c28aSwkPD4qPryKk3sU2JhXWLYYxhmDQMbM,1131
 tests/test_sm.py,sha256=FjcAbx4n7kLH00kjnKoGMk6t4_V9TJzIaxM21MkrOjE,83524
 tests/test_tksreader.py,sha256=8QtPAzxPJbkpxd1Nw2I7ggaTaKaL4WY55JJBHkZAzus,766
 tests/test_ts.py,sha256=tR2x5cKU9gw2fUprzaPgPbCvmDOHDO36JUPCCoTlY7Y,1833
 tests/test_vbfreader.py,sha256=-6oAhLJDb7K3Ui5O1mtHvbskawEfgyIH-Of5n-8u-fc,832
-tests/test_vtu.py,sha256=mZe-JDFUv0SDRofx8sH0R8mO2MGf1Evbvvd-Oc5DrRo,872
+tests/test_vtu.py,sha256=pGpHuAcaCk5zDYTBBp_akOEenZOpq-IzGl_kaMtodyA,1469
 tests/test_windings.py,sha256=PerbhIvIeyTuHZbBCORUy9EINKEhVoyN6vshtsrs1xA,4912
 tests/engines/__init__.py,sha256=l8HD-AY8EwxOoo_VrG3HgEZb2MaHypvnhKCVSkR-DTA,808
 tests/engines/test_amazon.py,sha256=4uy36NIo0epi3CgjUm8vl4snLpr4NRvUoWi6Zew_zcE,2014
@@ -196,9 +197,9 @@ tests/moo/__init__.py,sha256=l8HD-AY8EwxOoo_VrG3HgEZb2MaHypvnhKCVSkR-DTA,808
 tests/moo/test_algorithm.py,sha256=Em8sFm2vzPmuIzRrBBnUQLU_TYuJHSf-kEeozw0XeX4,2563
 tests/moo/test_population.py,sha256=FvX9LRCxQx0_E2GxHQ5vKwOYFBQiNbT6Lmv5GmNWjTQ,5471
 tests/moo/test_problem.py,sha256=ALeP4u7g-dFhfwWL8vxivdrrYzVKPjHMCAXzzgyNZbs,467
-femagtools-1.5.1.dist-info/LICENSE,sha256=V5OED7AzEaOtvbfgNheKOSUeNtijvKQuo84FtSJNkJU,1316
-femagtools-1.5.1.dist-info/METADATA,sha256=bnpCv2yda5Fv4hVrSzJXeHnr5wM2jNp9rD9Uj83K_yw,5685
-femagtools-1.5.1.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-femagtools-1.5.1.dist-info/entry_points.txt,sha256=UXpu6KnrykN89sCUaFAIIzn_dYwuxizUS0GcPdoekro,195
-femagtools-1.5.1.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.5.1.dist-info/RECORD,,
+femagtools-1.5.2.dist-info/LICENSE,sha256=V5OED7AzEaOtvbfgNheKOSUeNtijvKQuo84FtSJNkJU,1316
+femagtools-1.5.2.dist-info/METADATA,sha256=M2C4o3QLWJgrRNDvT0hE7k3yKK1WTroS-lzvUuhdIh0,5685
+femagtools-1.5.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+femagtools-1.5.2.dist-info/entry_points.txt,sha256=UXpu6KnrykN89sCUaFAIIzn_dYwuxizUS0GcPdoekro,195
+femagtools-1.5.2.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
+femagtools-1.5.2.dist-info/RECORD,,

tests/test_hxy.py

@@ -0,0 +1,19 @@
+import femagtools.hxy
+import pathlib
+import pytest
+
+
+@pytest.fixture
+def data_dir():
+    return pathlib.Path(__file__).with_name('data') / 'hxy'
+
+
+def test_read(data_dir):
+    num_magnets = 2
+    magnets = femagtools.hxy.read(data_dir / 'PM270L8_011.hxy',
+                                  num_magnets)
+    assert len(magnets) == num_magnets
+    assert set([len(m['e'][0]) for m in magnets]) == {169, 189}
+    assert [m['pos'][0] for m in magnets] == [0.0, 0.0]
+    assert sorted([m['havg'][0] for m in magnets]) == pytest.approx([156.3, 156.5], 0.1)
+    assert sorted([m['hmax'][0] for m in magnets]) == pytest.approx([195.6, 304.4], 0.1)

tests/test_sizing.py

@@ -15,7 +15,7 @@ def test_im():
     r = femagtools.machine.sizing.im(P, n, p, udc=udc,
                                      sigmas=fs, Ba=0.77,
                                      cos_phi=0.8, eta=0.8,
-                                     lda=0.9)
+                                     lda=0.9, rtype='statorRotor3')
     assert round(r['outer_diam'], 3) == 0.19
     assert r['stator']['num_slots'] == 36
 

tests/test_vtu.py

@@ -1,14 +1,19 @@
 import pytest
+import pathlib
 from femagtools import vtu
 
 
 @pytest.fixture
-def vtu_data():
-    filename = 'src/tests/data/zzz_pm_model_ts_results_1/zzz_pm_model_ts_0000.vtu'
-    return vtu.read(filename)
+def ts_data_dir():
+    return pathlib.Path(__file__).with_name('data') / 'zzz_pm_model_ts_results_1/'
+
+@pytest.fixture
+def demag_data_dir():
+    return pathlib.Path(__file__).with_name('data') / 'demag-vtu/'
 
 
-def test_read(vtu_data):
+def test_read(ts_data_dir):
+    vtu_data = vtu.read(ts_data_dir / 'zzz_pm_model_ts_0000.vtu')
     assert vtu_data.field_data_names == [
         'time [s]', 'angle [rad]',
         'speed [rad/s]', 'torque [Nm]',
@@ -23,3 +28,15 @@ def test_read(vtu_data):
     assert b[0] == pytest.approx([-0.003114], abs=1e-5)
     assert b[1] == pytest.approx([-0.00313], abs=1e-5)
     assert b[2] == [0.0]
+
+def test_demag(demag_data_dir):
+    vtu_data = vtu.read(demag_data_dir / 'PM_130_L10_0000.vtu')
+    keys = [7412, 7413, 7414, 7415, 7416]
+    class Element:
+        def __init__(self, key):
+            self.key = key
+    elements = [Element(k) for k in keys]
+    expected = [241.5, 250.2, 262.3, 276.5, 390.5]
+    actual = vtu_data.demag(elements)
+    assert len(actual) == 1
+    assert actual[0] == pytest.approx(expected, abs=0.1)