femagtools 1.7.9__py3-none-any.whl → 1.8.1__py3-none-any.whl

femagtools/__init__.py

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

femagtools/amela.py

@@ -200,10 +200,10 @@ class Amela():
         for k, i in enumerate(mag_spels):
 
             cond = i.conduc
-            if cond == 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)
 

femagtools/dxfsl/area.py

@@ -171,37 +171,141 @@ class Area(object):
                 if e1.n1 == e2.n1 and e1.n2 == e2.n2:
                     yield e1
 
-    def reduce_nodes(self, mindist=0.01):
+    def reduce_line_nodes(self, geom, mindist=0.01):
         """reduces number of nodes (lines only)
         https://rdp.readthedocs.io/en/latest
+        Note: this feature is deactivated silently
+          if the rdp package is not installed.
         """
-        import rdp
-        def reduce_nodes_(lines, mindist):
-            nodes = [le.get_nodes()[0] for le in lines]
-            r = rdp.rdp(nodes,
-                        epsilon=mindist)
-            if len(r) < len(nodes):
-                return [Line(Element(start=n1, end=n2))
-                        for n1, n2 in zip(r, r[1:])]
-            return lines
+        try:
+            import rdp
+        except ModuleNotFoundError:
+            return 0
+
+        def is_valid_line_(n1, e):
+            if not isinstance(e, Line):
+                return False
+            if e.has_attribute('del'):
+                return False
+            return True
 
+        def reduce_nodes_(lines, mindist):
+            if not len(lines) > 1:
+                return 0
+
+            nodes = [n1 for n1, n2, e in lines]
+            n1, n2, e = lines[-1]
+            nodes.append(n2)
+
+            remaining_nodes = rdp.rdp(nodes,
+                                      epsilon=mindist)
+            nodes_deleted = len(nodes) - len(remaining_nodes)
+            if not nodes_deleted:
+                return 0
+
+            for n1, n2, e in lines:
+                e.set_attribute('del')
+                e.set_my_color('yellow')
+                geom.remove_edge(e)
+
+            n1 = remaining_nodes[0]
+            for n2 in remaining_nodes[1:]:
+                geom.add_line(n1, n2)
+                n1 = n2
+
+            self.area = []
+            return nodes_deleted
+
+        # -----
+        nodes_deleted = 0
         lines = []
-        reduced = []
-        for e in self.area:
-            if isinstance(e, Line):
-                lines.append(e)
-            else:
-                reduced.append(e)
-                reduced += reduce_nodes_(lines, mindist)
+        for n1, n2, e in self.list_of_elements():
+            if not is_valid_line_(n1, e):
+                nodes_deleted += reduce_nodes_(lines, mindist)
                 lines = []
-        if lines:
-            reduced += reduce_nodes_(lines, mindist)
+            elif not geom.num_of_neighbors(n1) == 2:
+                nodes_deleted += reduce_nodes_(lines, mindist)
+                lines = [(n1, n2, e)]
+            else:
+                lines.append((n1, n2, e))
+
+        nodes_deleted += reduce_nodes_(lines, mindist)
+        return nodes_deleted
+
+    def reduce_element_nodes(self, geom, mindist=0.01):
+        """reduces number of nodes (lines only)
+        https://rdp.readthedocs.io/en/latest
+        Note: this feature is deactivated silently
+          if the rdp package is not installed.
+        """
+        corners = geom.start_corners + geom.end_corners
 
-        if len(self.area) > len(reduced):
-            logger.info("reduced areas %d -> %d",
-                        len(self.area), len(reduced))
-            return reduced
-        return []
+        try:
+            import rdp
+        except ModuleNotFoundError:
+            return 0
+
+        def is_valid_element_(n1, e):
+            return not e.has_attribute('del')
+
+        def reduce_nodes_(elements, mindist):
+            if not len(elements) > 1:
+                return 0
+
+            old_nodes = []
+            for n1, n2, e in elements:
+                old_nodes.append(n1)
+                nodes = [n for n in e.get_nodes(parts=24)]
+                if len(nodes) > 2:
+                    if points_are_close(n1, nodes[0]):
+                        old_nodes += nodes[1:-1]
+                    elif points_are_close(n2, nodes[0]):
+                        nodes.reverse()
+                        old_nodes += nodes[1:-1]
+            n1, n2, e = elmts[-1]
+            old_nodes.append(n2)
+
+            new_nodes = rdp.rdp(old_nodes,
+                                epsilon=mindist)
+            nodes_deleted = len(old_nodes) - len(new_nodes)
+            if not nodes_deleted:
+                return 0
+
+            for n1, n2, e in elements:
+                e.set_attribute('del')
+                e.set_my_color('yellow')
+                geom.remove_edge(e)
+
+            n1 = new_nodes[0]
+            for n2 in new_nodes[1:]:
+                geom.add_line(n1, n2)
+                n1 = n2
+
+            self.area = []
+            return nodes_deleted
+
+        # -----
+        nodes_deleted = 0
+        tiny_mindist = 0.05
+        elmts = []
+        has_tiny = False
+        for n1, n2, e in self.list_of_elements():
+            if not is_valid_element_(n1, e):
+                if has_tiny:
+                    nodes_deleted += reduce_nodes_(elmts, mindist)
+                elmts = []
+            elif not geom.num_of_neighbors(n1) == 2 or n1 in corners:
+                if has_tiny:
+                    nodes_deleted += reduce_nodes_(elmts, mindist)
+                has_tiny = e.is_tiny(tiny_mindist)
+                elmts = [(n1, n2, e)]
+            else:
+                if e.is_tiny(tiny_mindist):
+                    has_tiny = True
+                elmts.append((n1, n2, e))
+        if has_tiny:
+            nodes_deleted += reduce_nodes_(elmts, mindist)
+        return nodes_deleted
 
     def virtual_nodes(self, render=False, parts=64):
         if len(self.area) < 2:
@@ -718,9 +822,9 @@ class Area(object):
             mm[3] = max(mm[3], n[3])
         return mm
 
-    def intersect_line(self, line):
+    def intersect_area(self, line):
         for e in self.area:
-            if e.intersect_line(line):
+            if e.intersect_shape(line, include_end=True):
                 return True
         return False
 

femagtools/dxfsl/conv.py

@@ -9,18 +9,13 @@ import os
 import io
 import femagtools
 from femagtools.dxfsl.converter import convert
-from femagtools.dxfsl.journal import Journal, getJournal
 import argparse
 import logging
 import logging.config
 
 logger = logging.getLogger(__name__)
-journal = None
-
 
 def main():
-    global journal
-
     argparser = argparse.ArgumentParser(
         description='Process DXF file and create a plot or FSL file.')
     argparser.add_argument('dxfile',
@@ -187,8 +182,6 @@ def main():
         logger.info("Python: %s", sys.version)
         sys.exit(0)
 
-    journal = getJournal(name='converter_journal', aktiv=args.journal)
-
     if args.airgap > 0.0:
         if args.airgap2 > 0.0:
             logger.info("Airgap is set from {} to {}"
@@ -252,16 +245,11 @@ def main():
                   write_png=args.write_png,
                   write_id=args.write_id,
                   debug_mode=args.debugger,
-                  full_model=args.full_model)
+                  full_model=args.full_model,
+                  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})
-    if args.write_fsl:
-        if res is not None:
-            basename = os.path.basename(args.dxfile).split('.')[0]
-            with io.open(basename + '.fsl', 'w', encoding='utf-8') as f:
-                f.write('\n'.join(res['fsl']))
-    journal.write_journal()
 
 if __name__ == "__main__":
     loglevel = logging.INFO

femagtools/dxfsl/converter.py

@@ -2,7 +2,9 @@
 
 """
 import os
+import io
 from pathlib import Path
+from femagtools import __version__
 from femagtools.dxfsl.geom import Geometry
 from femagtools.dxfsl.shape import Shape
 from femagtools.dxfsl.fslrenderer import FslRenderer, agndst
@@ -159,12 +161,16 @@ 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():
         logger.debug("do nothing here with windings in rotor")
         logger.debug("End of build_machine_rotor")
         return machine
 
+    timer = Timer(start_it=True)
+
     if machine.is_mirrored():
         logger.debug("Rotor is mirrored")
         machine_temp = machine.undo_mirror()
@@ -206,41 +212,77 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
         machine_temp.create_inner_corner_areas()
 
     if not machine_temp.is_mirrored():
-        machine_temp.create_boundery_nodes()
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Rotor before Boundery Corr")
+        machine_temp.create_boundary_nodes()
 
     plot_geom(False,  # for developer
               plt, machine_temp.geom,
               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
 
 
 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)
+
     if not machine.geom.is_stator():
         logger.debug("Rotor with windings")
 
-    if machine.has_mirrored_windings():
+    if machine.is_mirrored():
+        plot_geom(False,  # for developer
+                  plt, machine.previous_machine.geom,
+                  title="Mirrored Stator",
+                  areas=True)
+
         logger.debug("undo mirrored windings")
         machine_temp = machine.undo_mirror()
         machine_temp.delete_tiny_elements(mindist)
         machine_temp.geom.set_stator()
         machine_temp.search_stator_subregions(single=single)
-        machine_temp.create_mirror_lines_outside_windings()
+        if not machine_temp.has_windings_in_the_middle():
+            logger.debug("Back to the mirrored machine")
+            machine_temp = machine  # undo
+        else:
+            machine_temp.create_mirror_lines_outside_windings()
     else:
         machine_temp = machine
+
+    if machine_temp.geom.reduce_element_nodes(mindist):
+        machine_temp.rebuild_subregions(EESM, single=single)
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Nodes reduced")
+
     if machine_temp.create_auxiliary_lines():
         machine_temp.rebuild_subregions(EESM, single=single)
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Stator with Auxiliary Lines")
 
     if inner:
         machine_temp.create_inner_corner_areas()
 
     if not machine_temp.is_mirrored():
-        machine_temp.create_boundery_nodes()
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Stator before Boundery Corr")
+        machine_temp.create_boundary_nodes()
 
     plot_geom(False,  # for developer
               plt, machine_temp.geom,
               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
 
@@ -270,7 +312,9 @@ def convert(dxfile,
             write_png=False,
             write_id=False,
             full_model=False,
-            debug_mode=False):
+            debug_mode=False,
+            write_journal=False):
+    global journal
     layers = ()
     conv = {}
 
@@ -281,14 +325,19 @@ def convert(dxfile,
 
     basename = input_file.stem
     if part:
-        logger.info("***** start processing %s (%s) *****", basename, part)
+        logger.info("***** start processing %s (%s) [%s] *****",
+                    basename,
+                    part,
+                    __version__)
     else:
-        logger.info("***** start processing %s *****", basename)
+        logger.info("***** start processing %s [%s] *****",
+                    basename,
+                    __version__)
     timer = Timer(start_it=True)
 
-    journal = getJournal(name='converter', aktiv=debug_mode)
+    journal = getJournal(name='converter_journal', aktiv=write_journal)
     journal.get_journal(input_file.name)
-    journal.put_filename(str(input_file.resolve()))
+    journal.set_filename(str(input_file.resolve()))
     journal.set('success', False)
     journal.write_journal()
 
@@ -533,7 +582,6 @@ def convert(dxfile,
                                                  EESM=EESM)
 
         if machine_outer.geom.is_stator() or machine_outer.has_windings():
-            machine_outer.geom.reduce_winding_nodes()
             machine_outer = build_machine_stator(machine_outer,
                                                  False,
                                                  mindist,
@@ -719,7 +767,6 @@ def convert(dxfile,
                                                p,
                                                EESM=EESM,
                                                single=True)
-                machine.geom.reduce_winding_nodes()
                 params = create_femag_parameters_stator(machine,
                                                         part[1])
             else:
@@ -794,14 +841,24 @@ def convert(dxfile,
 
             mtype = 'EESM' if EESM else 'PMSM'
             fslrenderer = FslRenderer(basename, mtype)
-            conv['fsl'] = fslrenderer.render(machine, inner, outer)
+            conv['fsl'] = fslrenderer.render(machine, inner, outer, standalone=True)
 
     if params is not None:
         conv.update(params)
+
+    if write_fsl:
+        logger.debug("Write fsl")
+        if conv and conv['fsl']:
+            with io.open(basename + '.fsl', 'w', encoding='utf-8') as f:
+                f.write('\n'.join(conv['fsl']))
+        else:
+            logger.warning("No fsl data available")
+
     conv['name'] = basename
     t = timer.stop("-- all done in %0.4f seconds --", info=True)
     journal.put('time_total', t)
     journal.set('success', True)
+    journal.write_journal()
     return conv
 
 

femagtools/dxfsl/fslrenderer.py

@@ -154,7 +154,7 @@ class FslRenderer(object):
         return sorted([(abs(r - np.linalg.norm(e.center_of_connection())), e)
                        for e in geom.elements(Shape)])
 
-    def render(self, machine, inner=False, outer=False):
+    def render(self, machine, inner=False, outer=False, standalone=False):
         '''create fsl statements with nodechains'''
         machine.set_alfa_and_corners()
         geom = machine.geom
@@ -162,20 +162,22 @@ class FslRenderer(object):
         geom.split_all_lines_longer_than(split_len)
         self.content = []
 
+        if standalone:
+            self.content += ['if (agndst == nil) then',
+                             '  agndst = 0.5',
+                             '  m.npols_gen = 2',
+                             '  m.num_sl_gen = 2',
+                             '  new_model_force("{}","Test")'.format(self.model),
+                             'end']
+
         MAXDST=4.0
         NUMLEVELS=10
-        ndt_list = [(0.00, 1.1),
-                    (0.05, 1.5),
-                    (0.10, 1.7),
-                    (0.15, 2.0),
-                    (0.20, 2.3),
-                    (0.30, 2.7),
-                    (0.40, 3.1),
-                    (0.50, 3.5),
-                    (0.70, 4.5),
-                    (0.85, 5.5),
-                    (1.10, 5.5)]
-        ndt_list = [(1.1*nl/NUMLEVELS, nl/NUMLEVELS*(MAXDST-1.1)+1.1)
+        NDT0=1.1
+        # ndt list format [ (rdistx, ndtx) ...]
+        # where
+        #   - rdistx is rel dist from airgap (range 0 .. NUMLEVELS-1/NUMLEVELS)
+        #   - ndtx nodedist (range NDT0 .. (NUMLEVELS-1/NUMLEVELS))*(MAXDST-1.1) + NDT0)
+        ndt_list = [(1.1*nl/NUMLEVELS, nl/NUMLEVELS*(MAXDST-1.1)+NDT0)
                     for nl in range(NUMLEVELS+1)]
 
         dist = geom.max_radius - geom.min_radius