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

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.4'
+__version__ = '1.8.6'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2024 Gamma Technology'

femagtools/bch.py

@@ -618,8 +618,8 @@ class Reader:
 
     def __read_peak_winding_currents(self, content):
         self.scData['peakWindingCurrents'] = [float(x)
-                                              for x in re.findall(r'[-0-9.]+',
-                                                                  ''.join(content))]
+                                              for x in self._numPattern.findall(
+                                                      ''.join(content))]
 
     def __read_general_machine_data(self, content):
         mcfiles = []
@@ -1771,6 +1771,9 @@ class Reader:
     def __getattr__(self, k):
         return self.__dict__[k]
 
+    def asdict(self):
+        return {k[0]: k[1] for k in self.items()}
+
     def items(self):
         return [(k, self.get(k)) for k in ('version',
                                            'type',

femagtools/dxfsl/area.py

@@ -435,6 +435,9 @@ class Area(object):
             self.type == TYPE_WINDINGS or \
             self.type == TYPE_FD_WINDINGS
 
+    def is_field_winding(self):
+        return self.type == TYPE_FD_WINDINGS
+
     def is_magnet(self):
         return self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT
 

femagtools/dxfsl/conv.py

@@ -180,12 +180,6 @@ def main():
                            help='create full model (fsl only)',
                            dest='full_model',
                            action="store_true")
-    argparser.add_argument('--no_processing',
-                           help=(argparse.SUPPRESS if not super_help else
-                                 "omit multiprocessing"),
-                           dest='no_processing',
-                           action="store_true",
-                           default=False)
 
     args = argparser.parse_args()
 
@@ -282,8 +276,7 @@ def main():
                   write_id=args.write_id,
                   debug_mode=args.debugger,
                   full_model=args.full_model,
-                  write_journal=args.journal,
-                  no_processing=args.no_processing)
+                  write_journal=args.journal)
     keys = ('tot_num_slot', 'num_sl_gen', 'num_poles', 'nodedist',
             'dy1', 'da1', 'da2', 'dy2', 'agndst', 'name')
     logger.info("%s", {k: res[k] for k in keys if k in res})

femagtools/dxfsl/converter.py

@@ -10,7 +10,7 @@ from femagtools.dxfsl.shape import Shape
 from femagtools.dxfsl.fslrenderer import FslRenderer, agndst
 from femagtools.dxfsl.plotrenderer import PlotRenderer
 from femagtools.dxfsl.concat import Concatenation
-from femagtools.dxfsl.functions import Timer, SimpleProcess, middle_angle
+from femagtools.dxfsl.functions import Timer, middle_angle
 from femagtools.dxfsl.journal import Journal, getJournal
 from femagtools.dxfsl.area import TYPE_WINDINGS
 from femagtools.dxfsl.areabuilder import disable_logging, enable_logging
@@ -18,10 +18,8 @@ import logging
 import logging.config
 import numpy as np
 import sys
-import multiprocessing
 
 logger = logging.getLogger(__name__)
-journal = None
 
 
 def plot_geom(doit, plt, geom, title="Plot", areas=True):
@@ -44,117 +42,6 @@ def plot_geom(doit, plt, geom, title="Plot", areas=True):
                         fill_areas=areas)
 
 
-class SymSearchProcess(SimpleProcess):
-    def __init__(self,
-                 name=None,
-                 queue=None,
-                 machine=None,
-                 plt=None,  # plotter
-                 kind="",
-                 mindist=0.01,
-                 symtol=0.0,
-                 sympart=0,
-                 is_inner=False,
-                 is_outer=False,
-                 show_plots=True,
-                 debug_mode=False,
-                 rows=1,
-                 cols=1,
-                 num=1,
-                 no_processing=False):
-        SimpleProcess.__init__(self,
-                               name=name,
-                               no_processing=no_processing)
-        self.queue = queue
-        self.mach_in = machine
-        self.mach_out = None
-        self.plt = plt
-        self.kind = kind
-        self.mindist = mindist
-        self.symtol = symtol
-        self.sympart = sympart
-        self.is_inner = is_inner
-        self.is_outer = is_outer
-        self.show_plots = show_plots
-        self.debug_mode = debug_mode
-        self.rows = rows
-        self.cols = cols
-        self.num = num
-        pass
-
-    def run(self):
-        if not self.without_processing():
-            logger.info("Process is running")
-            self.plt = None
-            self.show_plots = False
-        else:
-            logger.info("without multiprocessing")
-
-        try:
-            self.mach_out = symmetry_search(
-                self.mach_in,
-                plt=self.plt,
-                kind=self.kind,
-                mindist=self.mindist,
-                symtol=self.symtol,
-                sympart=self.sympart,
-                is_inner=self.is_inner,
-                is_outer=self.is_outer,
-                show_plots=self.show_plots,
-                debug_mode=self.debug_mode,
-                rows=self.rows,
-                cols=self.cols,
-                num=self.num)
-        except Exception as e:
-            logger.warning("Exception in symmetry_search: %s", e)
-        if not self.mach_out:
-            logger.error("NO MACHINE AFTER PROCESS")
-        self.queue.put(self.mach_out)
-        if not self.without_processing():
-            logger.info("Process is finished")
-
-
-class BuildInnerProcess(SimpleProcess):
-    def __init__(self,
-                 name=None,
-                 queue=None,
-                 machine=None,
-                 mindist=0.01,
-                 plt=None,  # plotter
-                 EESM=False,
-                 no_processing=False):
-        SimpleProcess.__init__(self,
-                               name=name,
-                               no_processing=no_processing)
-        self.queue = queue
-        self.mach_in = machine
-        self.mach_out = None
-        self.plt = plt
-        self.mindist = mindist
-        self.EESM = EESM
-        pass
-
-    def run(self):
-        if not self.without_processing():
-            logger.info("Process is running")
-            self.plt = None
-        else:
-            logger.info("without multiprocessing")
-
-        try:
-            self.mach_out = build_inner_machine(
-                self.mach_in,
-                mindist=self.mindist,
-                plt=self.plt,
-                EESM=self.EESM)
-        except Exception as e:
-            logger.warning("Exception in symmetry_search: %s", e)
-
-        self.queue.put(self.mach_out)
-        if not self.without_processing():
-            logger.info("Process is finished")
-
-
 def symmetry_search(machine,
                     plt=None,  # plotter
                     kind="single",
@@ -279,7 +166,6 @@ def symmetry_search(machine,
 
 
 def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
-    global journal
     logger.debug("Begin of build_machine_rotor")
 
     if machine.has_windings():
@@ -357,7 +243,6 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
 
 
 def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False):
-    global journal
     logger.debug("Begin of build_machine_stator")
     timer = Timer(start_it=True)
 
@@ -509,8 +394,7 @@ def convert(dxfile,
             write_id=False,
             full_model=False,
             debug_mode=False,
-            write_journal=False,
-            no_processing=False):
+            write_journal=False):
     global journal
     layers = ()
     conv = {}
@@ -729,23 +613,19 @@ def convert(dxfile,
                     machine_outer.set_outer()
 
         start_timer.stop("-- first part in %0.4f seconds --", info=True)
+
         process_timer = Timer(start_it=True)
         # inner part
-        inner_queue = multiprocessing.Queue()
-        inner_proc = SymSearchProcess(name="Inner",  # for logger
-                                      queue=inner_queue,
-                                      machine=machine_inner,
-                                      plt=None,  # plot
-                                      kind=inner_name,
-                                      is_inner=True,
-                                      mindist=mindist,
-                                      symtol=symtol,
-                                      show_plots=show_plots,
-                                      rows=3,  # rows
-                                      cols=2,  # columns
-                                      num=3,   # start num
-                                      no_processing=no_processing)
-        inner_proc.start_task()
+        machine_inner = symmetry_search(machine=machine_inner,
+                                        plt=p,  # plot
+                                        kind=inner_name,
+                                        is_inner=True,
+                                        mindist=mindist,
+                                        symtol=symtol,
+                                        show_plots=show_plots,
+                                        rows=3,  # rows
+                                        cols=2,  # columns
+                                        num=3)   # start num
 
         # outer part
         machine_outer = symmetry_search(machine_outer,
@@ -759,29 +639,20 @@ def convert(dxfile,
                                         cols=2,  # columns
                                         num=4)   # start num
 
-        machine_inner = inner_queue.get()
-        inner_proc.wait()
         process_timer.stop("-- symmetry search in %0.4f seconds --", info=True)
 
         machine_inner.sync_with_counterpart(machine_outer)
 
         final_timer = Timer(start_it=True)
-        inner_queue = multiprocessing.Queue()
-        inner_proc = BuildInnerProcess(name="Inner",  # for logger
-                                       queue=inner_queue,
-                                       machine=machine_inner,
-                                       mindist=mindist,
-                                       plt=p,
-                                       EESM=EESM,
-                                       no_processing=no_processing)
-        inner_proc.start_task()
+        machine_inner = build_inner_machine(machine_inner,
+                                            mindist=mindist,
+                                            plt=p,
+                                            EESM=EESM)
 
         machine_outer = build_outer_machine(machine_outer,
                                             mindist,
                                             p,
                                             EESM=EESM)
-        machine_inner = inner_queue.get()
-        inner_proc.wait()
         final_timer.stop("-- final part in %0.4f seconds --", info=True)
 
         machine_inner.sync_with_counterpart(machine_outer)
@@ -963,7 +834,7 @@ def convert(dxfile,
                 r_out = 0.0
                 r_in = 0.0
             if machine.cut_is_possible(r_in, r_out):
-                logger.info("make a cut")
+                logger.debug("make a cut")
                 machine = machine.cut(r_in, r_out)
 
         if part:
@@ -1085,6 +956,37 @@ def convert(dxfile,
     return conv
 
 
+def _create_rotor_parameters(machine):
+    rotor = {
+        'min_radius': machine.geom.min_radius,
+        'max_radius': machine.geom.max_radius,
+        'mags': machine.geom.magnets_minmax_list(),
+        'fd_wnds': machine.geom.fd_windings_minmax_list()
+    }
+    shaft_min, shaft_max = machine.geom.shaft_minmax()
+    if shaft_max > 0.0:
+        rotor['shaft_min'] = shaft_min
+        rotor['shaft_max'] = shaft_max
+    if shaft_max > rotor['min_radius']:
+        rotor['min_radius'] = shaft_max
+    return rotor
+
+
+def _create_stator_parameters(machine):
+    stator = {
+        'min_radius': machine.geom.min_radius,
+        'max_radius': machine.geom.max_radius,
+        'wnds': machine.geom.windings_minmax_list()
+    }
+    shaft_min, shaft_max = machine.geom.shaft_minmax()
+    if shaft_max > 0.0:
+        stator['shaft_min'] = shaft_min
+        stator['shaft_max'] = shaft_max
+    if shaft_max > stator['min_radius']:
+        stator['min_radius'] = shaft_max
+    return stator
+
+
 def create_femag_parameters(m_inner, m_outer, nodedist=1):
     if not (m_inner and m_outer):
         logger.warning("inner %s outer %s", m_inner, m_outer)
@@ -1127,6 +1029,13 @@ def create_femag_parameters(m_inner, m_outer, nodedist=1):
     params['alfa_slot'] = alfa_slot
     params['alfa_pole'] = alfa_pole
 
+    if m_inner.geom.is_rotor():
+        params['rotor'] = _create_rotor_parameters(m_inner)
+        params['stator'] = _create_stator_parameters(m_outer)
+    else:
+        params['rotor'] = _create_rotor_parameters(m_outer)
+        params['stator'] = _create_stator_parameters(m_inner)
+
     if num_slots == 0 or num_poles == 0:
         if num_slots == 0:
             logger.warning("No slots found")
@@ -1154,6 +1063,8 @@ def create_femag_parameters_stator(motor, position):
         params['dy1'] = 2*motor.geom.max_radius
         params['da1'] = 2*motor.geom.min_radius
     params['slot_area'] = motor.slot_area()
+    params['stator'] = _create_stator_parameters(motor)
+    params['machine'] = motor
     return params
 
 
@@ -1168,4 +1079,6 @@ def create_femag_parameters_rotor(motor, position):
         params['dy1'] = 2*motor.geom.max_radius
         params['da1'] = 2*motor.geom.min_radius
     params['slot_area'] = motor.slot_area()
+    params['rotor'] = _create_rotor_parameters(motor)
+    params['machine'] = motor
     return params

femagtools/dxfsl/geom.py

@@ -4528,6 +4528,55 @@ class Geometry(object):
                 add_element(e)
         self.area_list += area_list
 
+    def areas_minmax_list(self, area_list):
+        if not area_list:
+            return []
+
+        dist_list = []
+        for n, a in enumerate(area_list):
+            dist_list.append((a.min_dist, a.max_dist, n))
+        dist_list.sort()
+
+        minmax_list = []
+        d1_this, d2_this, n = dist_list [0]
+        for d1_next, d2_next, n in dist_list[1:]:
+            if d1_next > d2_this:
+                minmax_list.append((d1_this, d2_this))
+                d1_this = d1_next
+                d2_this = d2_next
+            else:
+                d2_this = max(d2_this, d2_next)
+        minmax_list.append((d1_this, d2_this))
+        return minmax_list
+
+    def magnets_minmax_list(self):
+        magnets = [a for a in self.list_of_areas()
+                   if a.is_magnet()]
+        return self.areas_minmax_list(magnets)
+
+    def windings_minmax_list(self):
+        windings = [a for a in self.list_of_areas()
+                    if a.is_winding()]
+        return self.areas_minmax_list(windings)
+
+    def fd_windings_minmax_list(self):
+        windings = [a for a in self.list_of_areas()
+                    if a.is_field_winding()]
+        return self.areas_minmax_list(windings)
+
+    def shaft_minmax(self):
+        shafts = [a for a in self.list_of_areas()
+                  if a.is_shaft()]
+        if not shafts:
+            return (0.0, 0.0)
+
+        dmin = shafts[0].min_dist
+        dmax = shafts[0].max_dist
+        for s in shafts[1:]:
+            dmin = min(dmin, s.min_dist)
+            dmax = max(dmax, s.max_dist)
+        return (dmin, dmax)
+
     def check_airgap_connecting_nodes(self, geom, startangle, endangle):
         logger.info("check_airgap_connecting_nodes")
 

femagtools/femag.py

@@ -802,8 +802,10 @@ class ZmqFemag(BaseFemag):
         """attaches a notify function"""
         logger.info("Subscribe on '%s' port %d", self.femaghost, self.port+1)
         if self.subscriber is None:
+            # progress/xyplot at a configured timestep published
+            header = [b'progress', b'xyplot', b'license']
             self.subscriber = femagtools.zmq.SubscriberTask(
-                port=self.port+1, host=self.femaghost, notify=notify)
+                port=self.port+1, host=self.femaghost, notify=notify, header=header)
             self.subscriber.start()
         else:
             # reattach?
@@ -1087,7 +1089,7 @@ class ZmqFemag(BaseFemag):
         response = self.send_request(
             ['CONTROL', f'getfile = {filename}'], timeout=1000)
         return [response[0].decode('latin1'),
-                response[1] if len(response) else b'']
+                response[1] if len(response) > 1 else b'']
 
     def exportsvg(self, fslcmds, timeout=10000):
         """get svg format from fsl commands (if any graphic created)
@@ -1156,6 +1158,7 @@ class ZmqFemag(BaseFemag):
         logger.info("Interrupt %s", self.femaghost)
         ctrl.send_string('interrupt')
         ctrl.close()
+        femagtools.zmq.SubscriberTask.clear()
 
     def copy_winding_file(self, name, wdg):
         wdg.write(name, self.workdir)