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

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.7.8'
+__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,6 +171,142 @@ class Area(object):
                 if e1.n1 == e2.n1 and e1.n2 == e2.n2:
                     yield e1
 
+    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.
+        """
+        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 = []
+        for n1, n2, e in self.list_of_elements():
+            if not is_valid_line_(n1, e):
+                nodes_deleted += reduce_nodes_(lines, mindist)
+                lines = []
+            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:
             return
@@ -337,15 +473,9 @@ class Area(object):
         return False
 
     def minmax_dist_from_center(self, center):
-        rmin = 1e20
-        rmax = 0
-        for n in self.list_of_nodes():
-            r = np.linalg.norm(np.array(n)-center)
-            if r < rmin:
-                rmin = r
-            if r > rmax:
-                rmax = r
-        return rmin, rmax
+        nodes = np.array([n for e in self.area for n in e.get_nodes()])
+        return (np.min(np.linalg.norm(nodes-center, axis=1)),
+                np.max(np.linalg.norm(nodes-center, axis=1)))
 
     def minmax_angle_dist_from_center(self, center, dist):
         circ = Circle(Element(center=center, radius=dist))
@@ -959,11 +1089,14 @@ class Area(object):
                                           self.legend())
 
     def remove_edges(self, g, ndec):
+        r = 0
         for e in self.area:
             try:
                 g.remove_edge(e.node1(ndec), e.node2(ndec))
+                r+=1
             except Exception:
                 continue
+        return r
 
     def is_circle(self):
         e = self.area[0]

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()
 
@@ -718,7 +742,6 @@ def convert(dxfile,
                                                p,
                                                EESM=EESM,
                                                single=True)
-
                 params = create_femag_parameters_stator(machine,
                                                         part[1])
             else:
@@ -801,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

@@ -162,17 +162,16 @@ class FslRenderer(object):
         geom.split_all_lines_longer_than(split_len)
         self.content = []
 
-        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)]
+        MAXDST=4.0
+        NUMLEVELS=10
+        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
         el_sorted = self.sorted_elements(geom, inner)
 
@@ -182,7 +181,7 @@ class FslRenderer(object):
             if ndt_list[n][0] < d_percent:
                 self.agndst = ndt_list[n][1] * self.agndst
                 self.content.append('\nndt({}*agndst)\n'.
-                                    format(ndt_list[n][1]))
+                                    format(round(ndt_list[n][1], 1)))
                 while ndt_list[n][0] < d_percent:
                     n += 1
             e.render(self)
@@ -233,6 +232,8 @@ class FslRenderer(object):
                 'r, phi = c2pr(x0, y0)',
                 'x1, y1 = pr2c(r1, phi)',
                 'x2, y2 = pr2c(r1, {}*math.pi/parts)'.format(slice),
+                f'-- end max corner {geom.end_corners[-1]}',
+                f'-- center {geom.center}',
                 f'r = {geom.dist_end_max_corner()}',
                 'x3, y3 = pr2c(r, {}*math.pi/parts)'.format(slice),
                 'nc_line(x0, y0, x1, y1, 0)',

femagtools/dxfsl/geom.py

@@ -91,11 +91,12 @@ def create_geometry(new_elements, split=False):
 
 
 def intersect_and_split(inp_elements, rtol, atol):
-    logger.info("Load input elements ... ")
+    logger.info("Load input elements ... %s", len(inp_elements))
     out_elements = []
     for e in inp_elements:
         out_size = len(out_elements)
         intersect_and_split_element(e, out_elements, 0, out_size, rtol, atol)
+    logger.debug(" done", e)
     return out_elements
 
 
@@ -650,9 +651,9 @@ class Geometry(object):
             return True
         return False
 
-    def get_edge(self, eg):
+    def get_edge(self, obj):
         return [[e[0], e[1], e[2]['object']] for e in self.g.edges(data=True)
-                if e[2]['object'] is eg]
+                if e[2]['object'] is obj]
 
     def get_edge_element(self, n1, n2):
         e_dict = self.g.get_edge_data(n1, n2)
@@ -679,9 +680,9 @@ class Geometry(object):
         assert(len(e) == 1)
         self._remove_edge(e[0][0], e[0][1])
 
-    def remove_edges(self, edges):
-        for e in edges:
-            self.remove_edge(e)
+    def remove_edges(self, objs):
+        for o in objs:
+            self.remove_edge(o)
 
     def _remove_node(self, n):
         for nbr in self.g.neighbors(n):
@@ -810,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
@@ -1843,6 +1848,24 @@ class Geometry(object):
             return [h for (k, h) in legend.items()]
         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 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:
             return
@@ -3587,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

femagtools/dxfsl/svgparser.py

@@ -37,10 +37,17 @@ def get_angles(sweep, center, p1, p2):
 def get_shapes(path):
     """return list of node elements (A, L)"""
     state = ''
+    prevstate = ''
     p = []
-    for s in [s for s in re.split('([AML])|,|\\s+',path) if s]:
+    for s in [s for s in re.split('([AMLHV])|,|\\s+', path) if s]:
         if state == '':
-            state = s[0]
+            s = s.upper()
+            if s in ('A','M','L','H','V'):
+                state = s
+                prevstate = s
+            else:  # wild guess
+                p.append(float(s))
+                state = prevstate
         elif state == 'M':
             p.append(float(s))
             if len(p) == 2:
@@ -52,7 +59,7 @@ def get_shapes(path):
             if len(p) == 2:
                 p2 = np.array(p)
                 logger.debug("Line %s -> %s",
-                            p1, p2)
+                             p1, p2)
                 yield Line(Element(start=p1, end=p2))
                 p1 = p2.copy()
                 p = []
@@ -66,7 +73,7 @@ def get_shapes(path):
                 center = get_center(r, p1, p2, sweep)
                 start, end = get_angles(sweep, center, p1, p2)
                 logger.debug("Arc center %s r %f %f -> %f",
-                            center, r, start, end)
+                             center, r, start, end)
                 yield Arc(Element(center=center,
                                   radius=r,
                                   start_angle=start*180/np.pi,
@@ -74,14 +81,34 @@ def get_shapes(path):
                 p1 = p2.copy()
                 p = []
                 state = ''
+        elif state == 'H':
+            logger.debug("h %s", s)
+            p2 = np.array((float(s), 0))
+            yield Line(Element(start=p1, end=p2))
+            p1 = p2.copy()
+            p = []
+            state = ''
+        elif state == 'V':
+            logger.debug("V %s", s)
+            p2 = np.array((0, float(s)))
+            yield Line(Element(start=p1, end=p2))
+            p1 = p2.copy()
+            p = []
+            state = ''
         else:
             raise ValueError(f"unsupported path {state}")
 
 
 def svgshapes(svgfile):
     svg = ET.parse(svgfile)
+    bcolor = re.compile('fill:([^;]+)')
+    sr = 0
     for p in svg.findall(".//{http://www.w3.org/2000/svg}path"):
+        m = bcolor.search(p.get('style'))
+        if m:
+            logger.info("subregion %d: %s", sr, m.groups()[0])
         yield from get_shapes(p.get('d'))
+        sr += 1
     for p in svg.findall(".//{http://www.w3.org/2000/svg}line"):
         yield Line(Element(start=[float(p.get('x1')), float(p.get('y1'))],
                            end=[float(p.get('x2')), float(p.get('y2'))]))