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

femagtools/__init__.py

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

femagtools/amela.py

@@ -200,7 +200,11 @@ class Amela():
         for k, i in enumerate(mag_spels):
 
             cond = i.conduc
-            mur = 1/i.elements[0].reluc[0]
+            if cond == 0: 
+                cond = 625000
+                logger.info('Magnet conductivity equals 0, using 625000 S/m')
+                
+            mur = np.abs(1/i.elements[0].reluc[0])
             logger.debug('Magnet: mur=%s, conductivity=%s', mur, cond)
 
             pm_elem_key.append([j.key for j in i.elements])

femagtools/femag.py

@@ -41,7 +41,7 @@ def handle_process_output(filedes, outfile, log):
     """read from file descriptor and direct lines to logger and outfile"""
     with open(outfile, 'w') as fp:
         for line in filedes:
-            fp.write(str(line))
+            fp.write(line.decode())
             if log:
                 if (b'' == line or
                     b'\x1b' in line or  # ignore terminal escape seq
@@ -482,7 +482,7 @@ class Femag(BaseFemag):
         basename = pathlib.Path(filename).name
         outname = os.path.join(self.workdir, basename+'.out')
         errname = os.path.join(self.workdir, basename+'.err')
-        with open(outname, 'w') as out, open(errname, 'w') as err:
+        with open(errname, 'w') as err:
             logger.info('invoking %s', ' '.join([str(a) for a in args]))
             proc = subprocess.Popen(
                 args,
@@ -495,9 +495,15 @@ class Femag(BaseFemag):
         errs = []
         # print femag output
         with io.open(outname, encoding='latin1', errors='ignore') as outfile:
+            errLine = False
             for l in outfile:
                 if l.find('ERROR') > -1:
                     errs.append(l.strip())
+                    errLine = True
+                elif errLine and l.startswith(' '):  # additional error line
+                    errs.append(l)
+                else:
+                    errLine = False
 
         rc = proc.returncode
         logger.info("%s exited with returncode %d (num errs=%d)",
@@ -508,7 +514,7 @@ class Femag(BaseFemag):
                 for l in errfile:
                     errs.append(l.strip())
             errs.insert(0, 'Exit code {}'.format(rc))
-            raise FemagError(errs)
+            raise FemagError("\n".join(errs))
 
     def cleanup(self):
         "removes all created files in workdir"
@@ -805,8 +811,8 @@ class ZmqFemag(BaseFemag):
                 logger.error("send_fsl: %s", str(e))
                 if timeout:  # only first call raises zmq.error.Again
                     return ['{"status":"error", "message":"Femag is not running"}', '{}']
-                msg = str(e)
-                return ['{"status":"error", "message":"'+msg+'"}', '{}']
+                msg = json.dumps(str(e))
+                return ['{"status":"error", "message":'+msg+'}', '{}']
 
     def run(self, options=['-b'], restart=False, procId=None,
             stateofproblem='mag_static'):  # noqa: C901
@@ -1003,6 +1009,18 @@ class ZmqFemag(BaseFemag):
             logger.warning(response[0])
         return [s.decode('latin1') for s in response]
 
+    def exportmesh(self, fslcmds, timeout=120000):
+        """get svg format (with mesh) from fsl commands (if any graphic created)
+        (since FEMAG v2024.1-17) """
+        response = self.send_request(['SVG+Mesh', fslcmds], timeout=timeout)
+        try:
+            rc = json.loads(response[0].decode('latin1'))
+            if rc['status'] == 'ok':
+                return self.getfile(rc['result_file'][0])
+        except json.decoder.JSONDecodeError:
+            logger.warning(response[0])
+        return [s.decode('latin1') for s in response]
+
     def interrupt(self):
         """send push message to control port to stop current calculation"""
         context = zmq.Context.instance()

femagtools/fsl.py

@@ -634,7 +634,7 @@ class Builder:
     def create_analysis(self, sim):
         pfefunc = sim.get('loss_funct', '')
         if pfefunc:
-            sim['loss_funct'] = 2 # 3?
+            sim['loss_funct'] = 1 # 3?
         airgap_induc = (self.create_airgap_induc()
                         if sim.get('airgap_induc', 0) else [])
         felosses = pfefunc.split('\n') + self.create_fe_losses(sim)

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/isa7.py

@@ -1357,13 +1357,15 @@ class Element(BaseEntity):
 
     def demagnetization(self, temperature=20):
         """return demagnetization Hx, Hy of this element"""
-        return self.demag_b(self.flux_density(cosys='cartes'), temperature)
+        return self.demag_b(self.flux_density(cosys='polar'), temperature)
 
     def demag_b(self, b, temperature):
         """return demagnetization Hx, Hy of this element at flux density b
           and temperature"""
         if self.is_magnet():
+            # 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

femagtools/machine/afpm.py

@@ -4,13 +4,16 @@
 import logging
 import numpy as np
 from pathlib import Path
+import shutil
 from .. import poc
 from .. import parstudy
 from .. import model
 from .. import utils
 from .. import windings
-from scipy.interpolate import RegularGridInterpolator, interp1d
+from .. import femag
+from scipy.interpolate import RegularGridInterpolator, interp1d, RectBivariateSpline
 from scipy.integrate import quad
+import copy
 
 logger = logging.getLogger(__name__)
 
@@ -36,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=[],
@@ -124,10 +171,6 @@ def parident(workdir, engine, temp, machine,
         ]
     }
 
-    pstudy = parstudy.List(
-        workdir, condMat=condMat, magnets=magnetMat,
-        magnetizingCurves=magnetizingCurves,
-        cmd=kwargs.get('cmd', None))
 
     ldq = []
     for magtemp in temp:
@@ -138,12 +181,37 @@ def parident(workdir, engine, temp, machine,
             poc=poc.Poc(999),
             speed=0)
         logging.info("Noload simulation")
-        nlresults = pstudy(nlparvardef, machine, nlcalc, engine)
-        if nlresults['status'].count('C') != len(nlresults['status']):
-            raise ValueError('Noload simulation failed %s', nlresults['status'])
+        if kwargs.get('use_multiprocessing', True): 
+            pstudy = parstudy.List(
+                    workdir, condMat=condMat, magnets=magnetMat,
+                    magnetizingCurves=magnetizingCurves,
+                    cmd=kwargs.get('cmd', None))
+
+            nlresults = pstudy(nlparvardef, machine, nlcalc, engine)
+            if nlresults['status'].count('C') != len(nlresults['status']):
+                raise ValueError('Noload simulation failed %s', nlresults['status'])
+        else: 
+            nlresults = {"x": [], "f": []}
+            i = 0
+            for pw, le, sp in zip(pole_width, lfe, linspeed): 
+                nlmachine = {k: machine[k] for k in machine}
+                nlmachine['pole_width'] = pw
+                nlmachine['lfe'] = le
+                nlcalc.update({"speed": sp})
+                nlsubdir = f'{workdir}/{i}'
+                nlworkdir = Path(nlsubdir)
+                if nlworkdir.exists(): 
+                    shutil.rmtree(nlworkdir)
+                nlworkdir.mkdir(exist_ok=True)
+                noloadsim = femag.Femag(nlworkdir, condMat=condMat, magnets=magnetMat,
+                                        magnetizingCurves=magnetizingCurves,
+                                        cmd=kwargs.get('cmd', None))
+                r = noloadsim(nlmachine, nlcalc)
+                nlresults['f'].append({k: v for k, v in r.items()})
+                i = i + 1
         nlresults.update(process(lfe, pole_width, machine, nlresults['f']))
-        current_angles = nlresults['f'][0]['current_angles']
 
+        current_angles = nlresults['f'][0]['current_angles']
         results = []
         i = 0
         for l, pw in zip(lfe, pole_width):
@@ -152,17 +220,11 @@ def parident(workdir, engine, temp, machine,
             mpart['lfe'] = l
             subdir = f"{workdir}/{i}"
 
-            gpstudy = parstudy.Grid(
-                subdir, condMat=condMat, magnets=magnetMat,
-                magnetizingCurves=magnetizingCurves,
-                cmd=kwargs.get('cmd', None))
-
             simulation = dict(
                 calculationMode="torq_calc",
                 wind_temp=20.0,
                 magn_temp=magtemp,
                 angl_i_up=0.0,
-                magnet_loss=True,
                 magn_height=machine['magnet']['afm_rotor']['magn_height'],
                 yoke_height=machine['magnet']['afm_rotor'].get(
                     'yoke_height', 0),
@@ -173,8 +235,36 @@ def parident(workdir, engine, temp, machine,
                 num_move_steps=60,
                 speed=linspeed[i],
                 num_par_wdgs=machine[wdgk].get('num_par_wdgs', 1))
-
-            lresults = gpstudy(parvardef, mpart, simulation, engine)
+            
+            if kwargs.get('use_multiprocessing', True): 
+                gpstudy = parstudy.Grid(
+                                    subdir, condMat=condMat, magnets=magnetMat,
+                                    magnetizingCurves=magnetizingCurves,
+                                    cmd=kwargs.get('cmd', None))
+                lresults = gpstudy(parvardef, mpart, simulation, engine)
+
+            else:
+                lresults = {"x": [], "f": []}
+                domain_beta = np.linspace(beta_min, 0, num_beta_steps).tolist()
+                domain_cur = np.linspace(i1_max/num_cur_steps, i1_max, num_cur_steps).tolist()
+                dir_index = 0
+                for cur in domain_cur: 
+                    for be in domain_beta:
+                        simulation['angl_i_up'] = be
+                        simulation['current'] = cur
+                        lresults['x'].append([be, cur])
+                        subsubdir = subdir + f'/{dir_index}'
+                        dir_index = dir_index + 1
+                        lworkdir = Path(subsubdir)
+                        if lworkdir.exists(): 
+                            shutil.rmtree(lworkdir)
+                        lworkdir.mkdir(exist_ok=True)
+                        loadsim = femag.Femag(lworkdir, condMat=condMat, magnets=magnetMat,
+                                            magnetizingCurves=magnetizingCurves,
+                                            cmd=kwargs.get('cmd', None))
+                        r = loadsim(mpart, simulation)
+                        lresults['f'].append({k: v for k, v in r.items()})
+                        
             f = [{k: bch[k]
                   for k in ('linearForce', 'flux', 'losses', 'lossPar')}
                  for bch in lresults['f']]
@@ -198,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],
@@ -214,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/multiproc.py

@@ -256,5 +256,5 @@ class Engine:
         try:
             self.pool.terminate()
             self.pool.close()
-        except AttributeError:
+        except AttributeError as e:
             logger.warn("%s", e)

femagtools/plot/nc.py

@@ -14,16 +14,21 @@ DEFAULT_CMAP='viridis'
 """default colormap (see https://matplotlib.org/stable/users/explain/colors/colormaps.html)"""
 
 
-def spel(isa, with_axis=False, ax=0):
+def spel(isa, superelements=[], with_axis=False, ax=0):
     """plot super elements of I7/ISA7 model
     Args:
       isa: Isa7 object
+      superelements: list of super elements (all if empty)
     """
     from matplotlib.patches import Polygon
     if ax == 0:
         ax = plt.gca()
     ax.set_aspect('equal')
-    for se in isa.superelements:
+    if superelements:
+        spels = superelements
+    else:
+        spels = isa.superelements
+    for se in spels:
         ax.add_patch(Polygon([n.xy
                               for nc in se.nodechains
                               for n in nc.nodes],
@@ -79,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)
@@ -130,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))
 
@@ -232,7 +237,7 @@ def flux_density_pos(isa, ipos, subreg=[], icur=-1, ibeta=-1, cmap=DEFAULT_CMAP,
     for e in elements:
         fd = isa.flux_density(e, icur, ibeta)
         b.append(np.linalg.norm(
-            (fd['bx'][ipos], fd['bx'][ipos])))
+            (fd['bx'][ipos], fd['by'][ipos])))
     fluxd = np.array(b)
     pos = isa.pos_el_fe_induction[ipos]*180/np.pi
     isa.rotate(isa.pos_el_fe_induction[ipos])

femagtools/templates/afm_stator.mako

@@ -16,6 +16,15 @@ m.slot_r2         =  ${model['slot_r2']*1e3}         -- Slot radius [mm]
 m.mcvkey_yoke     =  mcvkey_yoke
 m.nodedist        =  ${model.get('m.nodedist', 1)}  -- Node distance
 
+  -- overdeterminate slot_h2
+  if (math.abs(m.slot_h2 - m.slot_r1 - m.slot_h1) > 0) then
+     m.slot_h2 = m.slot_h1 + m.slot_r1
+  end
+  -- overdeterminate slot_open_width
+  if (m.slot_r1 > 0 and math.abs(m.slot_width - 2*m.slot_r1 - m.slot_open_width) > 0) then
+     m.slot_open_width = m.slot_width - 2*m.slot_r1
+  end
+
   if (m.model_type == "S1R2") or  (m.model_type == "S1R2_all") then
     if (m.st_yoke_height > 0) then
       m.st_yoke_height = 0
@@ -68,7 +77,7 @@ m.nodedist        =  ${model.get('m.nodedist', 1)}  -- Node distance
 
   if (m.slot_r1 > 0) then
     C1 = fml.Circle:Create(P33,m.slot_r1)
-    P32 = fml.Point:Tangent(P52,C1,2)
+    P32 = fml.Point:Tangent(P52,C1,1)
   end
 
   model_size = m.pole_width*m.num_poles*m.num_slots/m.tot_num_slot
@@ -77,7 +86,7 @@ m.nodedist        =  ${model.get('m.nodedist', 1)}  -- Node distance
 
   nc_line(P11.x,P11.y, P51.x,P51.y, 0)
   nc_line_cont(P52.x, P52.y, 0)
-  if P32 ~= nil then
+  if P32 ~= nil and m.slot_r1 > 0 then
     nc_line_cont(P32.x, P32.y, 0)
     nc_circle_m(P23.x,P23.y, P32.x,P32.y, P33.x,P33.y, m.slot_r1, 0)
   else

femagtools/templates/fieldcalc.mako

@@ -33,7 +33,5 @@ post_models("induct(x)","b")    -- Calculate field distribution
   until i>=N
   io.close(data)
 
-color_gradation(0,0,"tot","Babs",0,0,"")
 -- experimental (new femag-classic needed)
--- without grf_clear, overlay fieldlines with color gradation
-add_field_lines("field.svg", 25)
+export_calc_results('fieldcalc.vtu')

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.0.dist-info → femagtools-1.5.2.dist-info}/METADATA

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

@@ -1,7 +1,7 @@
-femagtools/__init__.py,sha256=eMGclaNbcY0JFMROit3E9gDgFcosrLZzcT5F3FYErwY,1615
+femagtools/__init__.py,sha256=kGZSfjN0Y6_CwYhVU9ki2misQXnylS2nmIQNI60q1lk,1615
 femagtools/airgap.py,sha256=s8NoKFvBhkINxkMLG02RbLZA9PiSx9KMtPjByy1WwNc,1584
 femagtools/amazon.py,sha256=O1ICuv21XDAJi1qK1Sigs2TdS6hDZP19OzvmE2t76wU,12069
-femagtools/amela.py,sha256=m1iRPzZRGHXyHz06Po20bPIYm60nPXC3ATcCUXx5qm8,13731
+femagtools/amela.py,sha256=pHjfXzpANI-7oz8MtrqNcyDZ6PxVM91vCJuvYhHy1rk,13891
 femagtools/asm.py,sha256=CiL0KWaF4P7O6-VwmGLdva_icwmPrPiI-TFQ19XYTKk,7660
 femagtools/bch.py,sha256=q6vMKFI0DSMQZDsOPAxMVPoxzz6aAUCApuwcW6c_oXM,70154
 femagtools/bchxml.py,sha256=KrRjAdrUPZXmiWvonu9HhpG_NvImMBpiXWTL4iSr4kE,3142
@@ -15,15 +15,15 @@ femagtools/dakotaout.py,sha256=6nn0PXsB40mPKiQLenqAtHy0KXCO7kvqqQ-aD2JhQvw,5573
 femagtools/docker.py,sha256=XDVmLBB0z4sZZpcrx7Wbm84xl4ksj7aqn5-ZOPxdxm4,7460
 femagtools/ecloss.py,sha256=boekPeuh3XlfdcEmtbg9IvmxeheX1PFm1ySv9QnY_90,12925
 femagtools/erg.py,sha256=IXKq76P9qLt_ssNOP78v8Qizk3J2Zg80yaKDSjzwoJE,1224
-femagtools/femag.py,sha256=kV0_iuEmCEUUXOaS2lNpCrxlmkQIKR4rS6TOvRCTE58,41522
+femagtools/femag.py,sha256=0XfEiXkfv2MWW6qh3D25Za4Vq9uDP_UIEyHCIBL_wok,42305
 femagtools/forcedens.py,sha256=nEM1MHxtpLee2sGFsehzrWEdsCRe_RSRqyNfj6u_l8g,7415
-femagtools/fsl.py,sha256=ufZ1hhER1RywRu-GvopszGAfVTbtcu5Jltv2XYONIbY,31377
+femagtools/fsl.py,sha256=3jbMaE63DMdm-2GxSFtTjMCfOI-Ql5xASe7L8IohRC8,31377
 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/isa7.py,sha256=2gre9mHYydA_uD0TxBkxsAU4phI9W3DK-QoZV9Us0A0,57297
+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
 femagtools/losscoeffs.py,sha256=dlSYDS13RqpPHLdv_EPWIA9liwhqjbxUiN7t7GFPZhw,5397
@@ -32,7 +32,7 @@ femagtools/mcv.py,sha256=Pll-r0YZh-wp9EQBTD4XEBlX4J5jy4oeVa22SYIM7q8,39744
 femagtools/me.py,sha256=XNK0l-aroNYfKyxV_uslE8q3vJb_KuntAYTWd-4FQaQ,1833
 femagtools/model.py,sha256=wcOZwKe8nd_vwe4SlLmWPe4ukvtVINUE8Qi5HEp2hkw,15018
 femagtools/moproblem.py,sha256=kOP8pRdD8YXz28_M2WKnFgl3eeJ7tqg49ohoazsmUOg,2825
-femagtools/multiproc.py,sha256=zzw2BECUw4oj_az3nT0py4S-zqyAl6IpMSccTLfr1_Y,8430
+femagtools/multiproc.py,sha256=7mJF-VU1NrJkENyg8eHtDrDRNBwLPK43phZv3ehm9BU,8435
 femagtools/mxw2msh.py,sha256=CIIqAvfs8U-A0OfuOAoDaqNSmoMSHSI_tW1CPFRCP5E,2151
 femagtools/nc.py,sha256=VQKpA2ZLoyvkQmzmHGrG7oePfGvynNw-pwqfavSxJx8,14233
 femagtools/netlist.py,sha256=CSCl8setLZ_L8DCnNWaNA3-wLe1yo-fmzARZoVvYfaA,2052
@@ -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=uSXO0e0MX4Y2dIJotesdKO55S1nz3c1EZJ1ho5QokwA,20017
+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,12 +79,12 @@ 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=Y1C0FdZs_dOA5YMUf3Fuz0ZfTNV9dD9g5aztKZrRFow,9380
+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
 femagtools/templates/afm_rotor.mako,sha256=fY-dlZvRLN9UAy5V6Q_inWghkSUe8pzrCYjJdNgfNXs,3112
-femagtools/templates/afm_stator.mako,sha256=LbsnLoXuF52qJHhqghj8jWJFRBiM3DGXqqQEtiGjhXI,5005
+femagtools/templates/afm_stator.mako,sha256=l1xEwxffZ1jyx5wuJ3rhVbVlZirJzD2K8n4i5Dvbxuc,5344
 femagtools/templates/airgapinduc.mako,sha256=aCMLZ7P4vjeSGikIetkwymgDjESdftPN_aYx2LfjfsY,246
 femagtools/templates/asyn_motor.mako,sha256=vvZ0SIJj4ORaCbE1Hl5NeCU_j2CWdOltVpSKP7ESJTQ,2879
 femagtools/templates/basic_modpar.mako,sha256=7qXIYrqJqI3xRnxXKG5zSwBNsiQotc94Q37X4sbAXxQ,3036
@@ -98,7 +98,7 @@ femagtools/templates/connect_models.mako,sha256=8j1hzBMeoDJ7-GL5BH-S5p53Bu5jtqqs
 femagtools/templates/cu_losses.mako,sha256=EeNwINYuwBuhbo9LH3STdQOTxOyyWw_BANgh_BSV9TE,1339
 femagtools/templates/ec-rotorbar.mako,sha256=RbA1TVNczEEddTNjvGLPxILExxp4rIgoxXe1YT6a4Is,1672
 femagtools/templates/fe-contr.mako,sha256=NoP7FQ62ITxgNmwP6GmkCnGhjEn5gPLUFgdLdhkKylY,1983
-femagtools/templates/fieldcalc.mako,sha256=-KgomjTDoWIJH-9nMyfkIWvfSjHnYYeuL8eIGyvZnCs,905
+femagtools/templates/fieldcalc.mako,sha256=yZ0_uAtdtzpv1uPjd92zyCbzTLhu2Rvvd5mRaOyesSU,806
 femagtools/templates/gen_winding.mako,sha256=yRe00f1L4_UuEOVwBkbEOL6rgG8NY43Jbpdud1nw4oo,3834
 femagtools/templates/inductances.mako,sha256=OpcW3E7LW09J8eoXylzfq2R16LKKxzJDr0PGCdHzixM,560
 femagtools/templates/ld_lq_fast.mako,sha256=BEQoplL7Ojqg5caldzAhMLKL-3E78wCSSbz5-KkDk2o,1359
@@ -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.0.dist-info/LICENSE,sha256=V5OED7AzEaOtvbfgNheKOSUeNtijvKQuo84FtSJNkJU,1316
-femagtools-1.5.0.dist-info/METADATA,sha256=JA6n507B4ZEi8wJjCA6QTIU99W-aBi10TJBmwV-VCBI,5685
-femagtools-1.5.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-femagtools-1.5.0.dist-info/entry_points.txt,sha256=UXpu6KnrykN89sCUaFAIIzn_dYwuxizUS0GcPdoekro,195
-femagtools-1.5.0.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.5.0.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)