femagtools 1.3.0__py3-none-any.whl → 1.3.2__py3-none-any.whl

femagtools/hxy.py

@@ -0,0 +1,126 @@
+# -*- coding: utf-8 -*-
+"""
+    femagtools.hxy
+    ~~~~~~~~~~~~~~
+
+    Reading HXY files (EXPERIMENTAL)
+
+"""
+
+import numpy as np
+from collections import defaultdict
+
+# K-means clustering
+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
+    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"""
+    hxy = []
+    with open(filename, encoding='latin1', errors='ignore') as f:
+        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:]})
+        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)
+        # move values to magnets:
+        magnets = [{'e': [p.coord for p in new_points if p.k == k],
+                    'pos': [], 'hxy': [], 'bxy': [], 'mxy': []}
+                   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)
+
+    return magnets

femagtools/isa7.py

@@ -196,7 +196,9 @@ class Reader(object):
             self.el_fe_induction_1.append([[]])
             self.el_fe_induction_2.append([[]])
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
-                self.el_fe_induction_1[0][0].append(self.next_block("h"))
+                b = self.next_block("h")
+                logger.debug("el_fe_induction move step %d: %d", i, len(b))
+                self.el_fe_induction_1[0][0].append(b)
                 self.el_fe_induction_2[0][0].append(self.next_block("h"))
 
         FC_NUM_MOVE_CALC_LOAD_PMS, FC_NUM_FLX = self.next_block("i")[0:2]
@@ -270,7 +272,9 @@ class Reader(object):
             self.el_fe_induction_2.append([[]])
             self.eddy_cu_vpot.append([[]])
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
-                self.el_fe_induction_1[1][0].append(self.next_block("h"))
+                b = self.next_block("h")
+                logger.debug("el_fe_induction move losses step %d: %d", i, len(b))
+                self.el_fe_induction_1[1][0].append(b)
                 self.el_fe_induction_2[1][0].append(self.next_block("h"))
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
                 self.eddy_cu_vpot[1][0].append(self.next_block("h"))
@@ -335,7 +339,10 @@ class Reader(object):
             self.el_fe_induction_2.append([[]])
             self.eddy_cu_vpot.append([[]])
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
-                self.el_fe_induction_1[2][0].append(self.next_block("h"))
+                b = self.next_block("h")
+                logger.debug("el_fe_induction move losses (2) step %d: %d",
+                            i, len(b))
+                self.el_fe_induction_1[2][0].append(b)
                 self.el_fe_induction_2[2][0].append(self.next_block("h"))
             for i in range(NUM_FE_EVAL_MOVE_STEP + 1):
                 self.eddy_cu_vpot[2][0].append(self.next_block("h"))
@@ -401,8 +408,8 @@ class Reader(object):
                 offset += chunksize
             logger.debug("%s: %d %d", fmt_, blockSize, len(unpacked))
         except struct.error as e:
-            logger.warning("Invalid Blocksize %s",
-                           blockSize)
+            logger.warning("Invalid Blocksize %s at pos %i",
+                           blockSize, self.pos-4)
 
         self.pos += blockSize + 4
 
@@ -688,25 +695,31 @@ class Isa7(object):
             self.curr_loss = np.array([c/np.sqrt(2) for c in reader.curr_loss])
         except AttributeError:
             pass
-        logger.debug(reader.el_fe_induction_1)
-        if len(np.asarray(reader.el_fe_induction_1).shape) > 2:
-            self.el_fe_induction_1 = np.asarray(
-                reader.el_fe_induction_1).T/1000
-            self.el_fe_induction_2 = np.asarray(
-                reader.el_fe_induction_2).T/1000
-            self.eddy_cu_vpot = np.asarray(reader.eddy_cu_vpot).T/1000
-        else:
-            try:
-                self.el_fe_induction_1 = np.asarray(
-                    [e for e in reader.el_fe_induction_1 if e[0]]).T/1000
-                self.el_fe_induction_2 = np.asarray(
-                    [e for e in reader.el_fe_induction_2 if e[0]]).T/1000
-                self.eddy_cu_vpot = np.asarray(
-                    [e for e in reader.eddy_cu_vpot if e[0]]).T/1000
-                logger.debug('El Fe Induction %s', np.asarray(
-                    reader.el_fe_induction_1).shape)
-            except:
-                pass
+
+        try:
+            el_fe_ind = [np.array(reader.el_fe_induction_1).T/1000,
+                         np.array(reader.el_fe_induction_2).T/1000]
+            eddy_cu_vpot = np.array(reader.eddy_cu_vpot).T/1000
+        except (ValueError, TypeError) as e:
+            # inhomogenous array
+            l = len(reader.el_fe_induction_1[0][0])
+            shape = []
+            for i in reader.el_fe_induction_1:
+                for j in i:
+                    n = 0
+                    for k in j:
+                        if len(k) < l:
+                            break
+                        n += 1
+                    if n > 0:
+                        shape.append(n)
+            el_fe_ind = [np.array([[reader.el_fe_induction_1[0][0][:shape[0]]]]).T/1000,
+                         np.array([[reader.el_fe_induction_2[0][0][:shape[0]]]]).T/1000]
+            eddy_cu_vpot = np.array([[reader.eddy_cu_vpot[0][0][:shape[0]]]]).T/1000
+
+        self.el_fe_induction_1 = el_fe_ind[0]
+        self.el_fe_induction_2 = el_fe_ind[1]
+        self.eddy_cu_vpot = eddy_cu_vpot
 
         self.iron_loss_coefficients = getattr(
             reader, 'iron_loss_coefficients', [])

femagtools/machine/__init__.py

@@ -35,6 +35,13 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     PM, EESM or IM"""
     rlfe = lfe
     rwdg = wdg
+    opts = {k: eecpars[k] for k in ('zeta1', 'gam', 'kh', 'kpfe',
+                                    'kfric_b') if k in eecpars}
+    try:
+        opts['rotor_mass'] = rlfe*eecpars['rotor_mass']
+    except KeyError:
+        pass
+
     if 'ldq' in eecpars or 'psidq' in eecpars:  # this is a PM (or EESM)
         try:
             dqpars = eecpars['ldq']
@@ -48,13 +55,9 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
             smpars['tcu1'] = temp[0]
             smpars['tcu2'] = temp[1]
             if 'ldq' in smpars:
-                machine = SynchronousMachineLdq(smpars, lfe=rlfe, wdg=rwdg)
+                machine = SynchronousMachineLdq(smpars, lfe=rlfe, wdg=rwdg, **opts)
             else:
-                machine = SynchronousMachinePsidq(smpars, lfe=rlfe, wdg=rwdg)
-            try:
-                machine.rotor_mass = rlfe*eecpars['rotor_mass']
-            except KeyError:
-                pass
+                machine = SynchronousMachinePsidq(smpars, lfe=rlfe, wdg=rwdg, **opts)
             return machine
 
         if isinstance(dqpars, list) and len(dqpars) > 1:
@@ -84,7 +87,8 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
                 losses=losses,
                 id=np.array(dqp['id'])/rwdg,
                 iq=np.array(dqp['iq'])/rwdg,
-                tcu1=temp[0])
+                tcu1=temp[0],
+                **opts)
         else:
             beta = dqp['beta']
             i1 = np.array(dqp['i1'])/rwdg
@@ -97,11 +101,8 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
                 losses=losses,
                 beta=beta,
                 i1=i1,
-                tcu1=temp[0])
-        try:
-            machine.rotor_mass = rlfe*eecpars['rotor_mass']
-        except KeyError:
-            pass
+                tcu1=temp[0],
+                **opts)
         return machine
 
     # must be an induction machine (TODO: check scaling)
@@ -111,7 +112,6 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     pars['lsigma2'] = rlfe*pars['lsigma2']
     pars['psiref'] = rwdg*rlfe*pars['psiref']
     pars['u1ref'] = rwdg*rlfe*pars['u1ref']
-    pars['rotor_mass'] = rlfe*pars['rotor_mass']
     pars['r2'] = rlfe*pars['r2']
     pars['fec'] = rlfe*pars['fec']
     pars['fee'] = rlfe*pars['fee']
@@ -119,6 +119,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     pars['psi'] = [psi*rwdg*rlfe for psi in pars['psi']]
     pars['tcu1'] = temp[0]
     pars['tcu2'] = temp[1]
+    pars.update(opts)
     return InductionMachine(pars)
 
 

femagtools/machine/effloss.py

@@ -1,6 +1,7 @@
 import numpy as np
 import scipy.interpolate as ip
 import logging
+import multiprocessing
 from .utils import betai1
 from .pm import PmRelMachineLdq, PmRelMachinePsidq, PmRelMachine
 from .sm import SynchronousMachine, SynchronousMachineLdq, SynchronousMachinePsidq
@@ -9,6 +10,88 @@ from . import create_from_eecpars
 logger = logging.getLogger("femagtools.effloss")
 
 
+def iqd_tmech_umax(m, u1, with_mtpa, progress, speed_torque, iq, id, iex):
+    """calculate iq, id for each load (n, T) from speed_torque at voltage u1
+
+        Arguments:
+        m: PmRelMachine or SynchronousMachine
+        u1: (float) phase voltage (V)
+        speed_torque: list of (n, T) pairs
+        with_mtpa: (bool) use mtpa in const flux range if True
+        progress: logging pipe """
+    nsamples = len(speed_torque)
+    num_iv = round(nsamples/7)
+    try:
+        for i, nT in enumerate(speed_torque):
+            iqde = m.iqd_tmech_umax(
+                nT[1], 2*np.pi*nT[0]*m.p,
+                u1, with_mtpa=with_mtpa)[:-1]
+            iq[i] = iqde[0]
+            id[i] = iqde[1]
+            if len(iqde) > 2:
+                iex[i] = iqde[2]
+            if i % num_iv == 0:
+                progress.send(f"{100*i/nsamples:.1f}%")
+    except Exception as e:
+        progress.send(e)
+    finally:
+        progress.close()
+
+def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa):
+    """calculate iqd for sm and pm using multiproc
+    """
+    progress_readers = []
+    chunksize = int(np.ceil(ntmesh.shape[1]/num_proc))
+    procs = []
+    iq = []
+    id = []
+    iex = []
+    iexk = []
+    k = 0
+    for i in range(0, num_proc*chunksize, chunksize):
+        prog_reader, prog_writer = multiprocessing.Pipe(duplex=False)
+        progress_readers.append(prog_reader)
+        iq.append(multiprocessing.Array('d', chunksize))
+        id.append(multiprocessing.Array('d', chunksize))
+        if isinstance(m, SynchronousMachine):
+            iex.append(multiprocessing.Array('d', chunksize))
+            iexk = iex[k]
+        p = multiprocessing.Process(target=iqd_tmech_umax,
+                                    args=(m, u1, with_mtpa,
+                                          prog_writer,
+                                          ntmesh.T[i:i+chunksize],
+                                          iq[k], id[k], iexk))
+        k += 1
+        p.start()
+        procs.append(p)
+        prog_writer.close()
+
+    i = 0
+    collected_msg = []
+    while progress_readers:
+        for r in multiprocessing.connection.wait(progress_readers):
+            try:
+                collected_msg.append(r.recv())
+                i += 1
+            except EOFError:
+                progress_readers.remove(r)
+            else:
+                if i % len(progress_readers) == 0:
+                    logger.info("Losses/Eff Map: %s",
+                                ', '.join(collected_msg))
+                    collected_msg = []
+    for p in procs:
+        p.join()
+    siz = ntmesh.shape[1]
+    if iex:
+        return np.array([np.array(iq).flatten(),
+                         np.array(id).flatten(),
+                         np.array(iex).flatten()])[:, :siz]
+
+    return np.array([np.array(iq).flatten(),
+                        np.array(id).flatten()])[:, :siz]
+
+
 def _generate_mesh(n, T, nb, Tb, npoints):
     """return speed and torque list for driving/braking speed range
 
@@ -34,7 +117,7 @@ def _generate_mesh(n, T, nb, Tb, npoints):
         def tbip(x): return 0
 
     nxtx = []
-    for nx in np.linspace(1, nmax, npoints[0]):
+    for nx in np.linspace(n[1], nmax, npoints[0]):
         t0 = tbip(nx)
         t1 = tip(nx)
         npnts = max(round((t1-t0) / (tmax-tmin) * tnum), 2)
@@ -49,7 +132,10 @@ def _generate_mesh(n, T, nb, Tb, npoints):
     return np.array(nxtx).T
 
 
-def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40)):
+def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
+                          with_mtpv=True, with_mtpa=True, with_pmconst=True,
+                          with_tmech=True, driving_only=False,
+                          num_proc=0, progress=None):
     """return speed, torque efficiency and losses
 
     arguments:
@@ -57,10 +143,16 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40)):
       dicts at different temperatures (or machine object)
     u1: (float) phase voltage (V rms)
     T: (float) starting torque (Nm)
-    temp: temperature (°C)
+    temp: temperature (°C) (ignored if eecpars is machine objectb)
     n: (float) maximum speed (1/s)
     npoints: (list) number of values of speed and torque
-
+    driving_only: (bool) do not calculate braking speed/torque samples if True
+    with_mtpv -- (optional) use mtpv if True (default)
+    with_pmconst -- (optional) use pmax if True (default)
+    with_mtpa -- (optional) use mtpa if True (default), disables mtpv if False
+    with_tmech -- (optional) use friction and windage losses (default)
+    num_proc -- (optional) number of parallel processes (default 0)
+    progress  -- (optional) custom function for progress logging
     """
     if isinstance(eecpars, dict):
         if isinstance(temp, (list, tuple)):
@@ -77,39 +169,67 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40)):
         nmax = n
         nsamples = npoints[0]
         rb = {}
-        r = m.characteristics(T, nmax, u1, nsamples=nsamples)  # driving mode
-        if isinstance(m, (PmRelMachineLdq, SynchronousMachineLdq)):
+        r = m.characteristics(T, nmax, u1, nsamples=nsamples,
+                              with_mtpv=with_mtpv, with_mtpa=with_mtpa,
+                              with_pmconst=with_pmconst, with_tmech=with_tmech)  # driving mode
+        if driving_only:
+            rb['n'] = None
+            rb['T'] = None
+        elif isinstance(m, (PmRelMachineLdq, SynchronousMachineLdq)):
             if min(m.betarange) >= -np.pi/2:  # driving mode only
                 rb['n'] = None
                 rb['T'] = None
-        if isinstance(m, (PmRelMachinePsidq, SynchronousMachinePsidq)):
+        elif isinstance(m, (PmRelMachinePsidq, SynchronousMachinePsidq)):
             if min(m.iqrange) >= 0:  # driving mode only
                 rb['n'] = None
                 rb['T'] = None
         if 'n' not in rb:
-            rb = m.characteristics(-T, max(r['n']), u1, nsamples=nsamples)  # braking mode
+            rb = m.characteristics(-T, max(r['n']), u1, nsamples=nsamples,
+                                   with_mtpv=with_mtpv, with_mtpa=with_mtpa,
+                                   with_pmconst=with_pmconst, with_tmech=with_tmech)  # braking mode
     ntmesh = _generate_mesh(r['n'], r['T'],
                             rb['n'], rb['T'], npoints)
 
-    class ProgressLogger:
-        def __init__(self, nsamples):
-            self.n = 0
-            self.nsamples = nsamples
-            self.num_iv = round(nsamples/15)
-        def __call__(self, iqd):
-            self.n += 1
-            if self.n % self.num_iv == 0:
-                logger.info("Losses/Eff Map: %d%%",
-                            round(100*self.n/self.nsamples))
-
+    logger.info("total speed,torque samples %d", ntmesh.shape[1])
     if isinstance(m, (PmRelMachine, SynchronousMachine)):
-        progress = ProgressLogger(ntmesh.shape[1])
-        iqd = np.array([
-            m.iqd_torque_umax(
-                nt[1],
-                2*np.pi*nt[0]*m.p,
-                u1, log=progress)[:-1]
-            for nt in ntmesh.T]).T
+        if num_proc > 1:
+            iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa)
+        else:
+            class ProgressLogger:
+                def __init__(self, nsamples):
+                    self.n = 0
+                    self.nsamples = nsamples
+                    self.num_iv = round(nsamples/15)
+                def __call__(self, iqd):
+                    self.n += 1
+                    if self.n % self.num_iv == 0:
+                        logger.info("Losses/Eff Map: %d%%",
+                                    round(100*self.n/self.nsamples))
+            if progress is None:
+                progress = ProgressLogger(ntmesh.shape[1])
+            else:
+                try:
+                    progress.nsamples=ntmesh.shape[1]
+                    progress(0)  # To check conformity
+                    progress.n = 0
+                except:
+                    logger.warning("Invalid ProgressLogger given to efficiency_losses_map, using default one!")
+                    progress = ProgressLogger(ntmesh.shape[1])
+            if with_tmech:
+                iqd = np.array([
+                    m.iqd_tmech_umax(
+                        nt[1],
+                        2*np.pi*nt[0]*m.p,
+                        u1, log=progress, with_mtpa=with_mtpa)[:-1]
+                    for nt in ntmesh.T]).T
+            else:
+                iqd = np.array([
+                    m.iqd_torque_umax(
+                        nt[1],
+                        2*np.pi*nt[0]*m.p,
+                        u1, log=progress, with_mtpa=with_mtpa)[:-1]
+                    for nt in ntmesh.T]).T
+
         beta, i1 = betai1(iqd[0], iqd[1])
         uqd = [m.uqd(2*np.pi*n*m.p, *i)
                for n, i in zip(ntmesh[0], iqd.T)]
@@ -138,10 +258,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40)):
         plmag = m.iqd_plmag(iqd[0], iqd[1], f1)
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], 2*np.pi*f1)
         plcu2 = m.iqd_plcu2(*iqd)
-        try:
-            tfric = m.kfric_b*m.rotor_mass*30e-3/np.pi
-        except AttributeError:
-            tfric = 0
+        tfric = m.tfric
     else:
         plfe1 = np.array(r['plfe1'])
         plfe2 = np.zeros(ntmesh.shape[1])
@@ -152,12 +269,16 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40)):
         u1 = np.array(r['u1'])
         i1 = np.array(r['i1'])
         try:
-            tfric = eecpars['kfric_b']*eecpars['rotor_mass']*30e-3/np.pi
+            if isinstance(eecpars, dict):
+                tfric = eecpars['kfric_b']*eecpars['rotor_mass']*30e-3/np.pi
+            else:
+                tfric = m.tfric
         except KeyError:
             tfric = 0
 
     plfric = 2*np.pi*ntmesh[0]*tfric
-    ntmesh[1] -= tfric
+    if not with_tmech:
+        ntmesh[1] -= tfric
     pmech = np.array(
         [2*np.pi*nt[0]*nt[1]
          for nt in ntmesh.T])