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

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.7.9'
+__version__ = '1.8.0'
 __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)
-
-        if len(self.area) > len(reduced):
-            logger.info("reduced areas %d -> %d",
-                        len(self.area), len(reduced))
-            return reduced
-        return []
+            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
+
+        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:

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,7 +245,8 @@ 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})
@@ -261,7 +255,6 @@ def main():
             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

@@ -3,6 +3,7 @@
 """
 import os
 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
@@ -220,16 +221,33 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
     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.create_auxiliary_lines():
+
+    rebuild = machine_temp.create_auxiliary_lines()
+    if machine_temp.geom.reduce_element_nodes(mindist):
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Nodes reduced",
+                  areas=False)
+        rebuild = True
+    if rebuild:
         machine_temp.rebuild_subregions(EESM, single=single)
 
     if inner:
@@ -270,7 +288,8 @@ def convert(dxfile,
             write_png=False,
             write_id=False,
             full_model=False,
-            debug_mode=False):
+            debug_mode=False,
+            write_journal=False):
     layers = ()
     conv = {}
 
@@ -281,14 +300,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 +557,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 +742,6 @@ def convert(dxfile,
                                                p,
                                                EESM=EESM,
                                                single=True)
-                machine.geom.reduce_winding_nodes()
                 params = create_femag_parameters_stator(machine,
                                                         part[1])
             else:
@@ -802,6 +824,7 @@ def convert(dxfile,
     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

@@ -164,18 +164,12 @@ class FslRenderer(object):
 
         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

femagtools/dxfsl/geom.py

@@ -811,6 +811,10 @@ class Geometry(object):
     def get_neighbors(self, n):
         return [nbr for nbr in self.g.neighbors(n)]
 
+    def num_of_neighbors(self, n):
+        nbrs = [nbr for nbr in self.g.neighbors(n)]
+        return len(nbrs)
+
     def angle_nodes(self, center, angle, rtol, atol):
         if np.isclose(abs(angle), np.pi, rtol, atol):
             angle_func = positive_angle
@@ -868,8 +872,8 @@ class Geometry(object):
         logger.debug("begin of dist_end_max_corner")
         logger.debug("end corners: %s", self.end_corners)
 
-        #if self.is_mirrored():
-        #    return self.dist_start_max_corner()
+        if self.is_mirrored():
+            return self.dist_start_max_corner()
         d = distance(self.center, self.end_corners[-1])
         logger.debug("end of dist_end_max_corner: %s", d)
         return d
@@ -1845,14 +1849,22 @@ class Geometry(object):
         return []
 
     def reduce_winding_nodes(self, mindist=0.01):
+        return self.reduce_element_nodes(mindist=mindist,
+                                         area_types=(AREA.TYPE_WINDINGS,))
+
+    def reduce_element_nodes(self, mindist=0.01, area_types=()):
+        timer = Timer(start_it=True)
+        nodes_deleted = 0
         for area in self.list_of_areas():
-            if area.is_winding():
-                reduced_shapes = area.reduce_nodes(mindist)
-                if reduced_shapes:
-                    area.remove_edges(self.g, ndec)
-                    area.area = reduced_shapes
-                    for r in reduced_shapes:
-                        self.add_element(r, rtol=self.rtol, atol=self.atol)
+            if not area_types or area.type in area_types:
+                nodes_deleted += area.reduce_element_nodes(self, mindist)
+
+        t = timer.stop("-- {} nodes deleted in %0.4f seconds --".format(nodes_deleted))
+        self.journal.put('time_deleting_nodes', t)
+        if nodes_deleted:
+            self.journal.put('nodes_deleted', nodes_deleted)
+            self.area_list = []
+        return nodes_deleted > 0
 
     def render_areagroups(self, renderer):
         if not self.areagroup_list:
@@ -3598,6 +3610,16 @@ class Geometry(object):
                 return True
         return False
 
+    def windings_in_the_middle(self, midangle):
+        wdg_areas = [a for a in self.list_of_areas()
+                     if a.is_winding()]
+        logger.info("%s windings in geom", len(wdg_areas))
+        for a in wdg_areas:
+            if greater(a.max_angle, midangle) and \
+               less(a.min_angle, midangle):
+                return True
+        return False
+
     def looking_for_corners(self):
         if self.is_inner:
             logger.debug("looking_for_corners: inner")

femagtools/dxfsl/journal.py

@@ -121,8 +121,8 @@ class Journal(object):
         data_list.append(val)
         self.data[name] = data_list
 
-    def put_filename(self, val):
-        self.put('filename', val)
+    def set_filename(self, val):
+        self.set('filename', val)
 
     def put_areas(self, val):
         self.put('areas', val)

femagtools/dxfsl/machine.py

@@ -5,14 +5,15 @@
 from __future__ import print_function
 import numpy as np
 import logging
-from .shape import Element, Circle, Arc, Line, Shape
-from .corner import Corner
+from femagtools.dxfsl.shape import Element, Circle, Arc, Line, Shape
+from femagtools.dxfsl.corner import Corner
 from femagtools.dxfsl.symmetry import Symmetry
-from .functions import point, points_are_close, distance
-from .functions import alpha_angle, normalise_angle, middle_angle, third_angle
-from .functions import alpha_line, line_m, line_n, mirror_point
-from .functions import within_interval, part_of_circle
-from .functions import less, less_equal, greater, greater_equal
+import femagtools.dxfsl.area as AREA
+from femagtools.dxfsl.functions import point, points_are_close, distance
+from femagtools.dxfsl.functions import alpha_angle, normalise_angle, middle_angle, third_angle
+from femagtools.dxfsl.functions import alpha_line, line_m, line_n, mirror_point
+from femagtools.dxfsl.functions import within_interval, part_of_circle
+from femagtools.dxfsl.functions import less, less_equal, greater, greater_equal
 logger = logging.getLogger('femagtools.geom')
 
 
@@ -283,11 +284,6 @@ class Machine(object):
         logger.debug("end of copy_mirror")
         return machine
 
-    def has_mirrored_windings(self):
-        if not self.is_mirrored():
-            return False
-        return self.geom.area_close_to_endangle(2) > 0
-
     def undo_mirror(self):
         assert(self.is_mirrored())
         assert(self.previous_machine)
@@ -533,7 +529,7 @@ class Machine(object):
     def repair_hull_geom(self, geom, startangle, endangle):
         logger.debug('begin repair_hull_geom (%s, %s)', startangle, endangle)
 
-        rtol = 1e-4
+        rtol = 1e-3
         atol = 1e-4
         c_corner = Corner(self.center, self.center)
         start_c_added, start_corners = geom.get_corner_list(self.center, startangle,
@@ -1138,6 +1134,11 @@ class Machine(object):
 
         return 0.0
 
+    def has_windings_in_the_middle(self):
+        midangle = middle_angle(self.startangle,
+                                self.endangle)
+        return self.geom.windings_in_the_middle(midangle)
+
     def create_mirror_lines_outside_windings(self):
         logger.debug("create_mirror_lines_outside_windings")
 

femagtools/dxfsl/shape.py

@@ -54,6 +54,9 @@ class Shape(object):
     def classname(self):
         return "Shape"
 
+    def set_my_color(self, color):
+        self.my_color = color
+
     def get_my_color(self):
         if hasattr(self, 'my_color'):
             return self.my_color