femagtools 1.5.1__tar.gz → 1.5.2__tar.gz

{femagtools-1.5.1/src/femagtools.egg-info → femagtools-1.5.2}/PKG-INFO

@@ -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 → femagtools-1.5.2}/src/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-1.5.2/src/femagtools/hxy.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+"""
+    femagtools.hxy
+    ~~~~~~~~~~~~~~
+
+    Reading HXY files (EXPERIMENTAL)
+    Build cluster of magnets
+"""
+
+import numpy as np
+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 readSections(f):
+    section = []
+    movepos = False
+    for line in f:
+        if line.startswith(' MOVE POSITION'):
+            movepos = True
+            if section:
+                # skip empty lines
+                i = 0
+                try:
+                    while not section[i]:
+                        i = i+1
+                except IndexError:
+                    i = i-1
+                yield section[i:]
+                section = []
+        if movepos:
+            section.append(line.strip())
+    yield section
+
+
+def read(filename, num_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
+        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': [[h['e'][p.index]*1e-3
+                           for p in points if p.k == k]
+                    for h in hxy]}
+                   for k in range(K)]
+
+        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-1.5.1 → femagtools-1.5.2}/src/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-1.5.1 → femagtools-1.5.2}/src/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-1.5.1 → femagtools-1.5.2}/src/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-1.5.1 → femagtools-1.5.2}/src/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-1.5.1 → femagtools-1.5.2}/src/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 → femagtools-1.5.2/src/femagtools.egg-info}/PKG-INFO

@@ -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 → femagtools-1.5.2}/src/femagtools.egg-info/SOURCES.txt

@@ -172,6 +172,7 @@ src/tests/test_erg.py
 src/tests/test_femag.py
 src/tests/test_forcedens.py
 src/tests/test_fsl.py
+src/tests/test_hxy.py
 src/tests/test_im.py
 src/tests/test_isa7.py
 src/tests/test_jhb.py

femagtools-1.5.2/src/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)

{femagtools-1.5.1 → femagtools-1.5.2}/src/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
 

femagtools-1.5.2/src/tests/test_vtu.py

@@ -0,0 +1,42 @@
+import pytest
+import pathlib
+from femagtools import vtu
+
+
+@pytest.fixture
+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(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]',
+        'winding 1 current [A]', 'winding 1 voltage [V]',
+        'winding 2 current [A]', 'winding 2 voltage [V]',
+        'winding 3 current [A]', 'winding 3 voltage [V]', 'branch names']
+    assert vtu_data.point_data_names == ['vector potential']
+    assert vtu_data.cell_data_names == [
+        'b', 'curd', 'demagnetization', 'current [A]', 'voltage [V]']
+
+    b = vtu_data.get_data_vector('b', 1)
+    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)