femagtools 1.5.0__tar.gz → 1.5.2__tar.gz

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

@@ -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 → femagtools-1.5.2}/src/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-1.5.0 → femagtools-1.5.2}/src/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-1.5.0 → femagtools-1.5.2}/src/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-1.5.0 → femagtools-1.5.2}/src/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-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.0 → femagtools-1.5.2}/src/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-1.5.0 → femagtools-1.5.2}/src/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-1.5.0 → 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.0 → 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.0 → femagtools-1.5.2}/src/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-1.5.0 → femagtools-1.5.2}/src/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])