femagtools 1.8.2__py3-none-any.whl → 1.8.4__py3-none-any.whl

femagtools/machine/sm.py

@@ -187,7 +187,7 @@ def parident(workdir, engine, machine,
 
     if simulation['calculationMode'] == 'ld_lq_fast':
         dqpars = dict(m=3, p=b['machine']['p'],
-                      r1=r1,
+                      r1=float(r1),
                       r2=machine['rotor'].get('resistance', 1),
                       rotor_mass=rotor_mass, kfric_b=1,
                       ldq=[dict(
@@ -434,9 +434,9 @@ class SynchronousMachine(object):
     def iqd_tmech(self, torque, n, disp=False, maxiter=500):
         """return currents for shaft torque with minimal losses"""
         if torque > 0:
-            startvals = self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = self.bounds[0][1]/2, 0, self.bounds[-1][1]
         else:
-            startvals = -self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = -self.bounds[0][1]/2, 0, self.bounds[-1][1]
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -463,9 +463,9 @@ class SynchronousMachine(object):
     def iqd_torque(self, torque, disp=False, maxiter=500):
         """return currents for torque with minimal losses"""
         if torque > 0:
-            startvals = self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = self.bounds[0][1]/2, 0, self.bounds[-1][1]
         else:
-            startvals = -self.bounds[0][1]/2, 0, sum(self.bounds[-1])/2
+            startvals = -self.bounds[0][1]/2, 0, self.bounds[-1][1]
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
@@ -483,14 +483,14 @@ class SynchronousMachine(object):
             #options={'disp': disp, 'maxiter': maxiter})
             if res['success']:
                 return res.x
-            logger.warning("%s: torque=%f %f, io=%s",
-                           res['message'], torque, self.torque_iqd(*startvals),
-                           startvals)
+        logger.warning("%s: torque=%f %f, io=%s",
+                       res['message'], torque, self.torque_iqd(*startvals),
+                       startvals)
         raise ValueError(res['message'])
 
     def mtpa(self, i1max):
         """return iq, id, iex currents and maximum torque per current """
-        T0 = self.torque_iqd(np.sqrt(2)*i1max/2, 0, self.bounds[-1][1]/2)
+        T0 = self.torque_iqd(np.sqrt(2)*i1max, 0, self.bounds[-1][1])
         def i1tq(tq):
             return abs(i1max) - np.linalg.norm(self.iqd_torque(tq)[:2])/np.sqrt(2)
         with warnings.catch_warnings():
@@ -501,7 +501,7 @@ class SynchronousMachine(object):
 
     def mtpa_tmech(self, i1max, n):
         """return iq, id, iex currents and maximum torque per current """
-        T0 = self.torque_iqd(np.sqrt(2)*i1max/2, 0, self.bounds[-1][0])/2
+        T0 = self.torque_iqd(np.sqrt(2)*i1max, 0, self.bounds[-1][1])
         def i1tq(tq):
             return i1max - np.linalg.norm(self.iqd_tmech(tq, n)[:2])/np.sqrt(2)
         tq = so.fsolve(i1tq, T0)[0]
@@ -517,14 +517,11 @@ class SynchronousMachine(object):
             if log:
                 log(iqde)
             return (*iqde, torque)
-        beta, i1 = betai1(iqde[0], iqde[1])
-        iex = iqde[2]
+        #beta, i1 = betai1(iqde[0], iqde[1])
+        #iex = iqde[2]
 
-        def ubeta(b):
-            return np.sqrt(2)*u1max - np.linalg.norm(
-                self.uqd(w1, *iqd(b, i1), iex))
-        beta = -np.pi/4 if torque>0 else -3*np.pi/4
-        io = *iqd(beta, i1), iex
+        #beta = 0 if torque>0 else np.pi
+        io = iqde[0], 0, iqde[2] #*iqd(beta, i1), iex
 
         #    logger.debug("--- torque %g io %s", torque, io)
         with warnings.catch_warnings():
@@ -540,17 +537,18 @@ class SynchronousMachine(object):
                 bounds=self.bounds,
                 constraints=[
                     {'type': 'eq',
-                     'fun': lambda iqd: self.tmech_iqd(*iqd, n) - torque},
+                     'fun': lambda iqd: torque - self.tmech_iqd(*iqd, n)},
                     {'type': 'eq',
-                     'fun': lambda iqd: np.linalg.norm(
-                         self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}])
+                     'fun': lambda iqd: u1max*np.sqrt(2)
+                       - np.linalg.norm(self.uqd(w1, *iqd))}])
             #if res['success']:
-        if log:
-            log(res.x)
-        return *res.x, self.tmech_iqd(*res.x, n)
-    #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-    #               res['message'], w1, torque, u1max, io)
-    #raise ValueError(res['message'])
+            if log:
+                log(res.x)
+            return *res.x, self.tmech_iqd(*res.x, n)
+        #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+        #               res['message'], w1, torque, u1max, io)
+        #raise ValueError(res['message'])
+        #return [float('nan')]*4
 
     def iqd_torque_umax(self, torque, w1, u1max,
                         disp=False, maxiter=500, log=0, **kwargs):
@@ -579,16 +577,15 @@ class SynchronousMachine(object):
                     {'type': 'eq',
                      'fun': lambda iqd: self.torque_iqd(*iqd) - torque},
                     {'type': 'eq',
-                     'fun': lambda iqd: np.linalg.norm(
-                         self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}])
-            if res['success']:
-
-                if log:
-                    log(res.x)
-                return *res.x, self.torque_iqd(*res.x)
-            logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-                           res['message'], w1, torque, u1max, io)
-        raise ValueError(res['message'])
+                     'fun': lambda iqd: u1max*np.sqrt(2) - np.linalg.norm(
+                         self.uqd(w1, *iqd))}])
+            #if res['success']:
+            if log:
+                log(res.x)
+            return *res.x, self.torque_iqd(*res.x)
+            #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+            #               res['message'], w1, torque, u1max, io)
+            #raise ValueError(res['message'])
 
     def w1_imax_umax(self, i1max, u1max):
         """return frequency w1 and shaft torque at voltage u1max and current i1max
@@ -672,9 +669,10 @@ class SynchronousMachine(object):
 
         wmtab = []
         dw = 0
-        wmMax = 3.5*wmType
+        wmMax = 5*wmType
         if n > 0:
             wmMax = min(wmMax, 2*np.pi*n)
+
         if wmType > wmMax:
             wmrange = sorted([0, wmMax])
             wmtab = np.linspace(0, wmMax, nsamples).tolist()

femagtools/mcv.py

@@ -8,10 +8,11 @@ import sys
 import copy
 import logging
 import os.path
+import pathlib
 import struct
 import math
 import numpy as np
-import scipy.interpolate as ip
+from scipy.interpolate import make_interp_spline
 from six import string_types
 import femagtools.losscoeffs as lc
 
@@ -98,7 +99,7 @@ def norm_pfe(B, pfe):
                 b = list(b)
                 b[-1] = Bv[n]
                 n += 1
-        pfunc = ip.interp1d(b, pfe[i], kind='cubic')
+        pfunc = make_interp_spline(b, pfe[i])
         m.append([float(pfunc(x))
                   for x in Bv[:n]] + [None]*(len(Bv)-n))
     return Bv.tolist(), m
@@ -167,8 +168,7 @@ def recalc_bsin(curve):
         if bi[0] > 0:
             bi.insert(0, 0)
             hi.insert(0, 0)
-        bh = ip.interp1d(bi, hi,
-                         kind='cubic', assume_sorted=True)
+        bh = make_interp_spline(bi, hi)
         for bx in c['bi'][2:]:
             bt = bx*np.sin(2*np.pi/4/ndel*x)
             nue = np.sum(bh(bt)/bt)/ndel
@@ -195,8 +195,7 @@ def recalc_hsin(curve):
         if hi[0] > 0:
             hi.insert(0, 0)
             bi.insert(0, 0)
-        hb = ip.interp1d(hi, bi,
-                         kind='cubic', assume_sorted=True)
+        hb = make_interp_spline(hi, bi)
         for hx in c['hi'][2:]:
             ht = hx*np.sin(2*np.pi/4/ndel*x)
             bt = hb(ht)*np.sin(2*np.pi/4/ndel*x)
@@ -242,11 +241,12 @@ def approx(db2, curve, ctype):
     if ctype in (DEMCRV, MAG_AC_CRV):
         dhdbn = 0
         k = len(bi2)-1
-        if curve['bi'][k] - curve['bi'][k-1] > 0:
-            dhdbn = ((curve['hi'][k] - curve['h'][k-1],KK)
-                     /(curve['bi'][k] - curve['bi'][k-1]))
-        a.append(MUE0*dhdbn)
-        b.append(MUE0*curve['hi'][k] - dhdbn*curve['bi'][k])
+        if k < len(curve['bi']):
+            if curve['bi'][k] - curve['bi'][k-1] > 0:
+                dhdbn = ((curve['hi'][k] - curve['h'][k-1])
+                         /(curve['bi'][k] - curve['bi'][k-1]))
+            a.append(MUE0*dhdbn)
+            b.append(MUE0*curve['hi'][k] - dhdbn*curve['bi'][k])
     else:
         a.append(1.0)
         b.append(MUE0*curve['hi'][-1]-curve['bi'][-1])
@@ -292,7 +292,12 @@ class Mcv(object):
         self.MC1_CW_FREQ_FACTOR = 0.0
         self.MC1_INDUCTION_FACTOR = 0.0
         self.MC1_INDUCTION_BETA_FACTOR = 0.0
-
+        self.jordan = {}
+        # {'ch': 0, 'cw': 0, 'ch_freq':0, 'cw_freq':0}
+        self.steinmetz = {}
+        # {'ch': 0, 'cw': 0, 'ch_freq':0, 'cw_freq':0}
+        self.bertotti = {}
+        # {'ch': 0, 'cw': 0, 'ce':0, 'ch_freq':0, 'cw_freq':0}
         self.MC1_FE_SPEZ_WEIGTH = 7.65
         self.MC1_FE_SAT_MAGNETIZATION = 2.15
 
@@ -354,6 +359,9 @@ class Mcv(object):
         for k in wtrans:
             if wtrans[k] in data.keys():
                 self.__setattr__(k, data[wtrans[k]])
+        for k in ('bertotti', 'jordan', 'steinmetz'):
+            if k in data:
+                self.__setattr__(k, data[k])
         self.curve = data['curve']
         try:
             self.mc1_angle = [c['angle'] for c in data['curve']]
@@ -363,6 +371,9 @@ class Mcv(object):
             self.losses = data['losses']
         except Exception:
             pass
+        # assume jordan iron loss parameters
+        for k in self.jordan:
+            self.jordan[k] = getattr(self, transl[k])
         return
 
     def rtrimValueList(self, vlist):
@@ -470,13 +481,25 @@ class Writer(Mcv):
                        for c in curve]
         return curve
 
-    def writeBinaryFile(self, fillfac=None, recsin=''):
+    def writeBinaryFile(self, fillfac=None, recsin='', feloss=''):
         """write binary file after conversion if requested.
         arguments:
         fillfac: (float) fill actor
         recsin: (str) either 'flux' or 'cur'
+        feloss: (str) iron loss method (bertotti, jordan)
         """
         curve = self._prepare(fillfac, recsin)
+        try:
+            if feloss.lower() == 'bertotti':
+                for k in self.bertotti:
+                    setattr(self, transl[k], self.bertotti[k])
+                del self.losses
+            else:
+                for k in self.jordan:
+                    setattr(self, transl[k], self.jordan[k])
+        except AttributeError as e:
+            logger.warning("%s", e)
+            pass
         mc1_type = self.mc1_type
         mc1_recalc = self.mc1_recalc
         mc1_fillfac = self.mc1_fillfac
@@ -556,6 +579,7 @@ class Writer(Mcv):
 
         try:
             if not (self.mc1_ch_factor or self.mc1_cw_factor) and self.losses:
+                # fit loss parameters
                 pfe = self.losses['pfe']
                 f = self.losses['f']
                 B = self.losses['B']
@@ -598,7 +622,8 @@ class Writer(Mcv):
             return
 
         try:
-            nfreq = len([1 for x in self.losses['f'] if x > 0])
+            freq = [x for x in self.losses['f'] if x > 0]
+            nfreq = len(freq)
             nind = len(self.losses['B'])
             if nind < 1 or nfreq < 1:
                 return
@@ -631,26 +656,28 @@ class Writer(Mcv):
             self.writeBlock([nfreq, nind])
             self.writeBlock([float(b) for b in B] + [0.0]*(M_LOSS_INDUCT - nind))
 
+            nrec = 0
             for f, p in zip(self.losses['f'], pfe):
                 if f > 0:
                     y = np.array(p)
                     losses = [float(x) for x in y[y != np.array(None)]]
-                    if len(losses) == nind:
-                        pl = p
+                    nloss = len(losses)
+                    if nloss == nind:
+                        pl = list(p)
                     else:
-                        n = len(losses)
                         cw, alfa, beta = lc.fitsteinmetz(
-                            f, B[:n], losses, Bo, fo)
+                            f, B[:nloss], losses, Bo, fo)
                         pl = losses + [lc.pfe_steinmetz(
                             f, b, cw, alfa, beta,
                             self.losses['fo'],
                             self.losses['Bo'])
-                                       for b in B[n:]]
+                                       for b in B[nloss:]]
                     logger.debug("%s", pl)
                     self.writeBlock(pl +
                                     [0.0]*(M_LOSS_INDUCT - len(pl)))
                     self.writeBlock(float(f))
-            for m in range(M_LOSS_FREQ - len(pfe)):
+                    nrec += 1
+            for m in range(M_LOSS_FREQ - nrec):
                 self.writeBlock([0.0]*M_LOSS_INDUCT)
                 self.writeBlock(0.0)
 
@@ -662,21 +689,21 @@ class Writer(Mcv):
         except Exception as e:
             logger.error("Exception %s", e, exc_info=True)
 
-    def writeMcv(self, filename, fillfac=None, recsin=''):
+    def writeMcv(self, filename, fillfac=None, recsin='', feloss='Jordan'):
         # windows needs this strip to remove '\r'
-        filename = filename.strip()
-        self.name = os.path.splitext(filename)[0]
+        filename = pathlib.Path(filename)
+        self.name = filename.stem
 
-        if filename.upper().endswith('.MCV') or \
-           filename.upper().endswith('.MC'):
+        if filename.suffix.upper() in ('.MCV', '.MC'):
             binary = True
-            self.fp = open(filename, "wb")
+            self.fp = filename.open(mode="wb")
         else:
             binary = False
-            self.fp = open(filename, "wb")
-        logger.info("Write File %s, binary format", filename)
+            self.fp = filename.open(mode="w")
+        logger.info("Write File %s, binary format (feloss '%s')",
+                    filename, feloss)
 
-        self.writeBinaryFile(fillfac, recsin)
+        self.writeBinaryFile(fillfac, recsin, feloss)
         self.fp.close()
 
 
@@ -737,17 +764,16 @@ class Reader(Mcv):
 
     def readMcv(self, filename):
         # intens bug : windows needs this strip to remove '\r'
-        filename = filename.strip()
+        filename = pathlib.Path(filename)
 
-        if filename.upper().endswith('.MCV') or \
-           filename.upper().endswith('.MC'):
+        if filename.suffix in ('.MCV', '.MC'):
             binary = True
-            self.fp = open(filename, "rb")
+            self.fp = filename.open(mode="rb")
         else:
             binary = False
-            self.fp = open(filename, "r")
+            self.fp = filename.open(mode="r")
 
-        self.name = os.path.splitext(os.path.basename(filename))[0]
+        self.name = filename.stem
         # read curve version (INTEGER)
         if binary:
             self.version_mc_curve = self.readBlock(int)
@@ -903,6 +929,8 @@ class Reader(Mcv):
         if self.MC1_INDUCTION_FACTOR > 2.0:
             self.MC1_INDUCTION_FACTOR = 2.0
 
+        # TODO: handle self.mc1_ce_factor, self.mc1_induction_beta_factor
+
         self.losses = {}
         try:
             (nfreq, njind) = self.readBlock([int, int])
@@ -1085,13 +1113,14 @@ class MagnetizingCurve(object):
                                 repls.items(), name)
 
     def writefile(self, name, directory='.',
-                  fillfac=None, recsin=''):
+                  fillfac=None, recsin='', feloss='jordan'):
         """find magnetic curve by name or id and write binary file
         Arguments:
           name: key of mcv dict (name or id)
           directory: destination directory (must be writable)
           fillfac: (float) new fill factor (curves will be recalulated if not None or 0)
           recsin: (str) either 'flux' or 'cur' recalculates for eddy current calculation (dynamic simulation)
+          feloss: (str) iron loss calc method ('jordan', 'bertotti', 'steinmetz')
 
         returns filename if found else None
         """
@@ -1125,7 +1154,7 @@ class MagnetizingCurve(object):
         filename = ''.join((bname, ext))
         writer = Writer(mcv)
         writer.writeMcv(os.path.join(directory, filename),
-                        fillfac=fillfac, recsin=recsin)
+                        fillfac=fillfac, recsin=recsin, feloss=feloss)
         return filename
 
     def fitLossCoeffs(self):

femagtools/multiproc.py

@@ -12,6 +12,8 @@ import pathlib
 import logging
 from .job import Job
 import femagtools.config as cfg
+import femagtools.zmq
+from femagtools.zmq import SubscriberTask
 try:
     from subprocess import DEVNULL
 except ImportError:
@@ -19,86 +21,40 @@ except ImportError:
 
 logger = logging.getLogger(__name__)
 
-numpat = re.compile(r'([+-]?\d+(?:\.\d+)?(?:[eE][+-]\d+)?)\s*')
-
 class LicenseError(Exception):
     pass
 
-class ProtFile:
-    def __init__(self, dirname, num_cur_steps):
-        self.size = 0
-        self.looplen = 0
-        self.cur_steps = [1, num_cur_steps]
-        self.n = 0
-        self.num_loops = 0
-        self.dirname = dirname
-        self.name = 'samples'
-
-    def percent(self):
-        if self.looplen > 0:
-            return min(100 * self.n / self.looplen, 100)
-        return 0
-
-    def update(self):
-        p = list(pathlib.Path(self.dirname).glob('*.PROT'))
-        if p:
-            buf = ''
-            if self.size < p[0].stat().st_size:
-                with p[0].open() as fp:
-                    fp.seek(self.size)
-                    buf = fp.read()
-            return self.append(buf)
-        return ''
-
-    def append(self, buf):
-        self.size += len(buf)
-        for line in [l.strip() for l in buf.split('\n') if l]:
-            if line.startswith('Loop'):
-                self.n = 0
-                try:
-                    cur_steps = self.cur_steps[self.num_loops]
-                except IndexError:
-                    cur_steps = 1
-                x0, x1, dx, nbeta = [float(f)
-                                     for f in re.findall(numpat, line)][:4]
-                move_steps = round((x1-x0)/dx+1)
-                beta_steps = int(nbeta)
-                self.looplen = cur_steps*beta_steps*move_steps
-                self.num_loops += 1
-            elif (line.startswith('Cur') or
-                  line.startswith('Id')):
-                self.n += 1
-            elif line.startswith('Number movesteps Fe-Losses'):
-                return ''
-            elif line.startswith('begin'):
-                self.name = line.split()[1].strip()
-
-        return f'{self.percent():3.1f}%'  # {self.n}/{self.looplen}'
-
-
 class ProgressLogger(threading.Thread):
-    def __init__(self, dirs, num_cur_steps, timestep):
+    def __init__(self, dirs, num_cur_steps, timestep, notify):
         threading.Thread.__init__(self)
-        self.dirs = dirs
-        self.num_cur_steps = num_cur_steps
+        self.protfiles = [femagtools.zmq.ProtFile(d, num_cur_steps)
+                          for d in dirs]
+        self.numTot = len(dirs)
         self.running = False
         self.timestep = timestep
+        self.notify = notify
 
     def run(self):
         self.running = True
-        protfiles = [ProtFile(d, self.num_cur_steps)
-                     for d in self.dirs]
         while self.running:
-            time.sleep(self.timestep)
-            logmsg = [p.update() for p in protfiles]
+            if self.timestep > 0:
+                time.sleep(self.timestep)
+            logmsg = [p.update() for p in self.protfiles]
             summary = [l  # f'<{i}> {l}'
                        for i, l in enumerate(logmsg)
                        if l]
             if summary:
-                labels = set([p.name for p in protfiles])
+                labels = set([p.name for p in self.protfiles])
                 logger.info('%s: %s',
                             ', '.join(labels),
                             ', '.join(summary))
+                if self.notify:
+                    numOf = f"{summary.count('100.0%')} of {self.numTot}"
+                    percent = sum([float(i[:-1])
+                                   for i in summary]) / self.numTot
+                    self.notify(
+                        ["progress_logger",
+                         f"{self.numTot}:{numOf}:{percent}:{' '.join(summary)}"])
             else:
                 logger.info('collecting FE losses ...')
                 return
@@ -107,7 +63,7 @@ class ProgressLogger(threading.Thread):
         self.running = False
 
 
-def run_femag(cmd, workdir, fslfile):
+def run_femag(cmd, workdir, fslfile, port):
     """Start the femag command as subprocess.
 
     :internal:
@@ -120,7 +76,8 @@ def run_femag(cmd, workdir, fslfile):
     with open(os.path.join(workdir, "femag.out"), "wb") as out, \
             open(os.path.join(workdir, "femag.err"), "wb") as err:
         try:
-            proc = subprocess.Popen(cmd + ['-b', fslfile],
+            args = ['-b', str(port), fslfile] if port else ['-b', fslfile]
+            proc = subprocess.Popen(cmd + args,
                                     shell=False,
                                     stdin=DEVNULL,
                                     stdout=out,
@@ -163,11 +120,16 @@ class Engine:
         cmd: the program (executable image) to be run
             (femag dc is used if None)
         process_count: number of processes (cpu_count() if None)
-        progress_timestep: time step in seconds for progress log messages if > 0)
+        timestep: time step in seconds for progress log messages if > 0)
     """
 
     def __init__(self, **kwargs):
         self.process_count = kwargs.get('process_count', None)
+        self.notify = kwargs.get('notify', None)
+        # cogg_calc mode, subscribe xyplot
+        self.calc_mode = kwargs.get('calc_mode')
+        self.port = kwargs.get('port', 0)
+        self.curve_label = kwargs.get('curve_label')
         cmd = kwargs.get('cmd', '')
         if cmd:
             self.cmd = [cmd]
@@ -175,7 +137,10 @@ class Engine:
                 self.cmd.append('-m')
 
         self.progressLogger = 0
-        self.progress_timestep = kwargs.get('timestep', 5)
+        self.progress_timestep = kwargs.get('timestep', -1)
+        self.subscriber = None
+        self.job = None
+        self.tasks = []
 
     def create_job(self, workdir):
         """Create a FEMAG :py:class:`Job`
@@ -209,20 +174,41 @@ class Engine:
                 t.cmd = [cfg.get_executable(
                     t.stateofproblem)] + args
 
-        self.pool = multiprocessing.Pool(self.process_count)
-        self.tasks = [self.pool.apply_async(run_femag,
-                                            args=(t.cmd,
-                                                  t.directory,
-                                                  t.fsl_file))
-                      for t in self.job.tasks]
+        num_proc = self.process_count
+        if not num_proc and multiprocessing.cpu_count() > 1:
+            num_proc = min(multiprocessing.cpu_count()-1, len(self.job.tasks))
+        self.pool = multiprocessing.Pool(num_proc)
+        if self.port:
+            header = [b'progress']
+            if self.calc_mode == 'cogg_calc':
+                header +=[b'xyplot']
+            self.subscriber = [SubscriberTask(port=self.port + i * 5,
+                                              host='127.0.0.1',
+                                              notify=self.notify,
+                                              header=header,
+                                              curve_label=self.curve_label,
+                                              num_cur_steps=self.job.num_cur_steps,
+                                              timestep=self.progress_timestep
+                                              )
+                               for i, t in enumerate(self.job.tasks)]
+            [s.start() for s in self.subscriber]
+            self.tasks = [self.pool.apply_async(
+                run_femag, args=(t.cmd, t.directory, t.fsl_file, self.port + i * 5))
+                          for i, t in enumerate(self.job.tasks)]
+        else:
+            self.tasks = [self.pool.apply_async(
+                run_femag, args=(t.cmd, t.directory, t.fsl_file, 0))
+                          for t in self.job.tasks]
         self.pool.close()
 
-        if (self.progress_timestep and
-                self.job.num_cur_steps):
+        # only works on linux
+        if (self.progress_timestep and not self.port and
+            self.job.num_cur_steps):
             self.progressLogger = ProgressLogger(
                 [t.directory for t in self.job.tasks],
                 num_cur_steps=self.job.num_cur_steps,
-                timestep=self.progress_timestep)
+                timestep=self.progress_timestep,
+                notify=self.notify)
             self.progressLogger.start()
         return len(self.tasks)
 
@@ -244,17 +230,30 @@ class Engine:
                     if t.errmsg:
                         logger.error(t.errmsg)
             status.append(t.status)
+        self.stopThreads()
+        self.pool = None # garbage collector deletes threads
+        return status
+
+    def stopThreads(self):
+        """ stop all running treads
+        """
         if self.progressLogger:
             self.progressLogger.stop()
-        return status
+        if self.port and self.subscriber:
+            [s.stop() for s in self.subscriber]
+            SubscriberTask.clear()
+            self.subscriber = None
 
     def terminate(self):
+        """ terminate all
+        """
         logger.info("terminate Engine")
-        if self.progressLogger:
-            self.progressLogger.stop()
+        self.stopThreads()
+
         # terminate pool
         try:
-            self.pool.terminate()
-            self.pool.close()
+            if self.pool:
+                self.pool.terminate()
+                self.pool = None # garbage collector deletes threads
         except AttributeError as e:
             logger.warn("%s", e)