femagtools 1.8.5__py3-none-any.whl → 1.8.7__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.5'
+__version__ = '1.8.7'
 __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 = []
@@ -1057,10 +1057,11 @@ class Reader:
         e.g. : idList[-450, -350, -250, -150, -50, 0]
                idList[-500, -400, -300, -200, -100, 0, 0]
         '''
-        diff = np.floor(np.abs(np.diff(idList)))
-        if idList[-1] == 0 and len(idList) > 2 and \
-           diff[-1] == 0:
+        if list(idList).count(0) > 1: # femag writes duplicate id==0 values
             idList = idList[:-1]
+        diff = np.floor(np.abs(np.diff(idList)))
+        if n := np.trim_zeros(np.diff(diff)).size:
+            idList = idList[:-n]
         return idList
 
     def __read_psidq(self, content):
@@ -1085,8 +1086,7 @@ class Reader:
             ncols = ncols-1
 
         id = np.reshape(m[0], (-1, ncols)).T[0]
-        if id[0] >= 0:
-            id = self.__removeTrailingZero(id)
+        id = self.__removeTrailingZero(id)
         nrows = len(id)
         if nrows > 1 and id[nrows-1] < id[nrows-2]:
             nrows = nrows-1
@@ -1121,8 +1121,7 @@ class Reader:
             ncols = ncols-1
 
         id = np.reshape(m[0], (-1, ncols)).T[0]
-        if id[0] >= 0:
-            id = self.__removeTrailingZero(id)
+        id = self.__removeTrailingZero(id)
         nrows = len(id)
         if nrows > 1 and id[nrows-1] < id[nrows-2]:
             nrows = nrows-1
@@ -1610,6 +1609,11 @@ class Reader:
                         losses['staza'] = floatnan(rec[0])
                         losses['stajo'] = floatnan(rec[1])
                         losses['total'] += losses['staza']+losses['stajo']
+
+                    elif content[i+1].split() == ['Iron', '----']:
+                        losses['rotfe'] = sum([floatnan(x) for x in rec])
+                        losses['total'] += losses['rotfe']    
+                        
                     else:
                         losses['rotfe'] = floatnan(rec[1])
                         losses['total'] += losses['rotfe']
@@ -1771,6 +1775,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,7 +18,6 @@ import logging
 import logging.config
 import numpy as np
 import sys
-import multiprocessing
 
 logger = logging.getLogger(__name__)
 
@@ -43,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",
@@ -348,6 +236,7 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
               title="Final Rotor")
 
     t = timer.stop("-- rotor created in %0.4f seconds --")
+    journal.put('time_rotor_created', t)
 
     logger.debug("End of build_machine_rotor")
     return machine_temp
@@ -420,6 +309,7 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
               title="Final Stator")
 
     t = timer.stop("-- stator created in %0.4f seconds --")
+    journal.put('time_stator_created', t)
 
     logger.debug("End of build_machine_stator")
     return machine_temp
@@ -504,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 = {}
@@ -724,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,
@@ -754,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)
@@ -958,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:
@@ -1080,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)
@@ -1122,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")
@@ -1149,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
 
 
@@ -1163,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

@@ -61,43 +61,6 @@ def handle_process_output(filedes, outfile, log):
                         pass
 
 
-def get_shortCircuit_parameters(bch, nload):
-    try:
-        if nload < 0:
-            nload = 0
-        if nload > 2:
-            nload = 2
-        if nload > 0:
-            dqld = bch.dqPar['ld']
-            dqlq = bch.dqPar['lq']
-            dqpsim = bch.dqPar['psim']
-            if len(dqld) <= nload or len(dqlq) <= nload or len(dqpsim) <= nload:
-                ld = dqld[-1]/bch.armatureLength
-                lq = dqlq[-1]/bch.armatureLength
-                psim = dqpsim[-1]/bch.armatureLength
-            else:
-                ld = dqld[nload-1]/bch.armatureLength
-                lq = dqlq[nload-1]/bch.armatureLength
-                psim = dqpsim[nload-1]/bch.armatureLength
-        else:
-            ld = bch.machine['ld']/bch.armatureLength
-            lq = bch.machine['lq']/bch.armatureLength
-            psim = bch.machine['psim']/bch.armatureLength
-        return dict(
-            r1=bch.machine['r1'],
-            ld=ld,
-            lq=lq,
-            psim=psim,
-            num_pol_pair=bch.machine['p'],
-            fc_radius=bch.machine['fc_radius'],
-            lfe=bch.armatureLength/1e3,
-            pocfilename=bch.machine['pocfile'],
-            num_par_wdgs=bch.machine.get('num_par_wdgs', 0),
-            calculationMode='shortcircuit')
-    except (KeyError, AttributeError, IndexError):
-        raise FemagError("missing pm/Rel-Sim results")
-
-
 def set_magnet_properties(model, simulation, magnets):
     """set temperature adapted magnet properties"""
     if not hasattr(model, 'magnet'):
@@ -449,7 +412,7 @@ class BaseFemag(object):
 
         return list(pathlib.Path(self.workdir).glob('*.PROT'))[0].stem
 
-    def readResult(self, simulation, bch=None):
+    def readResult(self, machine, simulation, bch=None):
         if simulation:
             if simulation['calculationMode'] == "fieldcalc":
                 nc = self.read_nc()
@@ -495,38 +458,11 @@ class BaseFemag(object):
             if simulation['calculationMode'] == 'pm_sym_fast' or \
                 simulation['calculationMode'] == 'torq_calc':
                 if simulation.get('shortCircuit', False):
-                    logger.info("short circuit simulation")
-                    simulation.update(
-                        get_shortCircuit_parameters(bch,
-                                                    simulation.get('initial', 2)))
-
-                    builder = femagtools.fsl.Builder(self.templatedirs)
+                    from .shortcircuit import shortcircuit
                     set_magnet_properties(self.model, simulation, self.magnets)
-                    fslcmds = (builder.open_model(self.model) +
-                               builder.create_shortcircuit(simulation))
-                    fslfile = 'shortcicuit.fsl'
-                    with open(os.path.join(self.workdir, fslfile), 'w') as f:
-                        f.write('\n'.join(fslcmds))
-                    self.run(fslfile) #, options?
-                    bchfile = self.get_bch_file(self.modelname)
-                    if bchfile:
-                        bchsc = femagtools.bch.Reader()
-                        logger.info("Read BCH {}".format(bchfile))
-                        with io.open(bchfile, encoding='latin1',
-                                     errors='ignore') as f:
-                            bchsc.read(f)
-                    bch.scData = bchsc.scData
-                    for w in bch.flux:
-                        try:
-                            bch.flux[w] += bchsc.flux[w]
-                            bch.flux_fft[w] += bchsc.flux_fft[w]
-                        except (KeyError, IndexError):
-                            logging.debug(
-                                "No additional flux data in sc simulation")
-                            break
-
-                    bch.torque += bchsc.torque
-                    bch.demag += bchsc.demag
+                    bch.scData = shortcircuit(self, machine, bch, simulation)
+                    #bch.torque += bchsc.torque
+                    #bch.demag += bchsc.demag
 
             if 'airgap_induc' in simulation:
                 try:
@@ -699,8 +635,9 @@ class Femag(BaseFemag):
             setattr(self, "dy2", machine['stator']['dy2'])
         except:
             pass
+
         if simulation:
-            return self.readResult(simulation)
+            return self.readResult(machine, simulation)
 
         return {'status': 'ok', 'message': self.modelname,
                 'model': self.model.props()}
@@ -801,9 +738,12 @@ class ZmqFemag(BaseFemag):
     def subscribe(self, notify):
         """attaches a notify function"""
         logger.info("Subscribe on '%s' port %d", self.femaghost, self.port+1)
+        femagtools.zmq.SubscriberTask.clear()
         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 +1027,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 +1096,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)

femagtools/fsl.py

@@ -227,7 +227,7 @@ class Builder:
             #  obsolete
             th_props = [' ']
             try:
-                logger.info(model.magnet)
+                logger.debug(model.magnet)
                 th_props = [f'rotor_density = {model["magnet"]["density"]}',
                             f'rotor_thcond = {model["magnet"]["thcond"]}',
                             f'rotor_thcap = {model["magnet"]["thcap"]}'
@@ -750,8 +750,11 @@ class Builder:
                 sim['eccentricity'])
 
         if sim.get('calculationMode') == 'pm_sym_f_cur':
-            if 'nload_ex_cur' in sim.keys():  # convert obsolete key
-                sim['noload_ex_cur'] = sim.pop('nload_ex_cur')
+            if sim.get('nload_ex_cur', ''):  # convert obsolete key
+                if isinstance(sim, dict):
+                    sim['noload_ex_cur'] = sim.pop('nload_ex_cur')
+                else:
+                    sim.noload_ex_cur = sim.get('nload_ex_cur')
         felosses = custom_fefunc + self.create_fe_losses(sim)
         fslcalc = (displ_stator_rotor
                    + self.__render(sim, sim.get('calculationMode'))