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

femagtools/__init__.py

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

femagtools/dxfsl/area.py

@@ -100,6 +100,9 @@ class Area(object):
     def elements(self):
         return self.area
 
+    def copy_of_elements(self):
+        return [e.clone() for e in self.elements() if e]
+
     def list_of_nodes(self):
         if len(self.area) < 1:
             return
@@ -822,9 +825,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
 
@@ -1208,6 +1211,7 @@ class Area(object):
 
         angles.sort(reverse=True)
         # calculate orientation (no rectangle check)
+
         l, alpha = angles[0]
         phi = normalise_angle(alpha + np.pi/2)
         logger.debug("alpha = %s, phi = %s", alpha, phi)
@@ -1216,9 +1220,13 @@ class Area(object):
         angle = alpha_angle(mid, phi)
         logger.debug("phi=%s, mid=%s, angle=%s", phi, mid, angle)
 
-        if greater(angle, np.pi * 0.5, rtol=1e-5) and \
+        if np.isclose(mid, alpha, rtol=1e-3, atol=1e-3):
+            phi = mid
+            logger.debug("correction of phi=%s", phi)
+        elif greater(angle, np.pi * 0.5, rtol=1e-5) and \
            less(angle, np.pi * 1.5, rtol=1e-5):
             phi = normalise_angle(phi + np.pi)
+            logger.debug("correction of phi=%s", phi)
 
         logger.debug("phi of magnet %s is %s", self.identifier(), phi)
         return phi
@@ -1321,6 +1329,32 @@ class Area(object):
         return np.isclose(angle, border_angle,
                           rtol=1e-03, atol=1e-03)
 
+    def set_subregion_parameters(self,
+                                 is_inner,
+                                 min_radius,
+                                 max_radius,
+                                 startangle,
+                                 endangle):
+        ag_delta = (max_radius - min_radius) / 500.0
+        if is_inner:
+            self.close_to_ag = greater_equal(self.max_dist + ag_delta, max_radius)
+            close_to_opposition = np.isclose(min_radius, self.min_dist)
+            airgap_radius = max_radius
+            opposite_radius = min_radius
+        else:
+            self.close_to_ag = less_equal(self.min_dist - ag_delta, min_radius)
+            close_to_opposition = np.isclose(max_radius, self.max_dist)
+            airgap_radius = min_radius
+            opposite_radius = max_radius
+
+        airgap_toleranz = (self.max_dist - self.min_dist) / 50.0  # 2%
+
+        self.close_to_startangle = np.isclose(self.min_angle, startangle,
+                                              1e-04, 1e-04)
+        self.close_to_endangle = np.isclose(self.max_angle, endangle,
+                                            1e-04, 1e-04)
+        self.surface = self.area_size()
+
     def mark_stator_subregions(self,
                                is_inner,
                                stator_size,
@@ -1791,6 +1825,16 @@ class Area(object):
             for i in a.nested_areas_inside():
                 yield i
 
+    def mirror_area(self, center, axis_m, axis_n):
+        elements = []
+        for e in self.area:
+            el = e.mirror_shape(center, axis_m, axis_n)
+            if el:
+                elements.append(el)
+        area = Area(elements, center, 0.0)
+        area.type = self.type
+        return area
+
     def __str__(self):
         return "Area {}\n".format(self.id) + \
             "distance...............: from {} to {}\n".\

femagtools/dxfsl/areabuilder.py

@@ -338,7 +338,7 @@ class EdgeInfo(object):
         return True  # two lines
 
     def arc_line_direction_lefthand(self, start_edge, line_edge, builder):
-        logger.info("begin of arc_line_direction_lefthand")
+        logger.debug("begin of arc_line_direction_lefthand")
         if not self.is_arc():
             logger.critical("FATAL: unexpected %s at position %s", self.classname(), self.n1)
             sys.exit(1)
@@ -630,7 +630,7 @@ class AreaBuilder(object):
         logger.debug("begin of create_inner_corner_auxiliary_areas")
         if not self.geom.is_inner:
             logger.debug("end of create_inner_corner_auxiliary_areas: not inner")
-            return
+            return False
 
         self.set_edge_attributes()
 
@@ -647,17 +647,18 @@ class AreaBuilder(object):
 
         if start_exists and end_exists:
             logger.debug("end of create_inner_corner_auxiliary_areas: no aktion")
-            return
+            return False
 
         airgap_line, airgap_el = self.get_inner_airgap_line()
         if not airgap_el:
             logger.debug("end of create_inner_corner_auxiliary_areas: no airgapline found")
-            return
+            return False
 
         logger.debug("airgapline found !!")
         airgap_nodes = [n for n in airgap_line[1:]]
         del airgap_nodes[-1]
 
+        created = False
         if not start_exists:
             cp = self.geom.start_corners[-1]
             logger.debug("Start Corner: %s -- %s", cp, start_cp)
@@ -683,6 +684,7 @@ class AreaBuilder(object):
                                            n,
                                            color='red',
                                            linestyle='dotted')
+                    created = True
                     start_node = self.geom.get_node(start_cp)
                     self.geom.add_edge(cp, start_node, start_line)
                     result = self.get_new_area(start_node, n)
@@ -715,6 +717,7 @@ class AreaBuilder(object):
                         self.geom.add_line(end_cp, n,
                                            color='red',
                                            linestyle='dotted')
+                    created = True
                     end_node = self.geom.get_node(end_cp)
                     self.geom.add_edge(cp, end_node, end_line)
                     result = self.get_new_area(n, end_node)
@@ -725,81 +728,126 @@ class AreaBuilder(object):
                     break
 
         logger.debug("end of create_inner_corner_auxiliary_areas")
+        return created
 
-    def get_inner_airgap_line(self):
-        logger.debug("begin of get_inner_airgap_line")
-        assert(self.geom.is_inner)
-        assert(self.geom.area_list)
-
-        area = [a for a in self.geom.area_list if a.close_to_ag_endcorner]
-        if len(area) != 1:
-            logger.debug("end of get_inner_airgap_line: %s areas found", len(area))
-            return [], []
+    def get_airgap_line(self, start_node, end_node, area):
+        logger.debug("get_airgap_line")
 
-        end_corner = self.geom.end_corners[-1]
-        logger.debug("END CORNER %s", end_corner)
+        self.set_edge_attributes()
 
-        nodes = [n for n in area[0].list_of_nodes()]
+        nodes = [n for n in area.list_of_nodes()]
         if not nodes:
-            logger.debug("end of get_inner_airgap_line: no nodes found")
+            logger.debug("end of get_airgap_line: no nodes found")
             return [], []
 
         n1 = nodes[0]
-        if points_are_close(end_corner, n1):
+        if points_are_close(start_node, n1):
             n2 = nodes[-1]
         else:
             n2 = n1
             for n1 in nodes[1:]:
-                if points_are_close(end_corner, n1):
+                if points_are_close(start_node, n1):
                     break
                 n2 = n1
 
-        if not points_are_close(end_corner, n1):
-            logger.debug("end of get_inner_airgap_line: not close to endcorner")
+        if not points_are_close(start_node, n1):
+            logger.debug("end of get_airgap_line: not close to start-node")
             return [], []
 
-        start_corner = self.geom.start_corners[-1]
-        logger.debug("START CORNER %s", end_corner)
-
-        logger.debug("EDGE FOUND: %s - %s", n1, n2)
+        logger.debug("START EDGE FOUND: %s - %s", n1, n2)
         nodes = [n1, n2]
         info = self.get_edge_info(n1, n2)
         elements = [info.element]
 
-        while not points_are_close(start_corner, n2):
+        while not points_are_close(end_node, n2):
             info.set_start_angle()
             info = self.next_edge_lefthand_side(info)
             if not info:  # bad
-                return []
+                return [], []
             n2 = info.n2
             nodes.append(n2)
             elements.append(info.element)
 
-        logger.debug("end of get_inner_airgap_line #%s", len(nodes))
+        logger.debug("end of get_airgap_line #%s", len(nodes))
         return nodes, elements
 
-    def get_element_line(self, start_node, end_node):
-        logger.debug("begin of get_element_line")
+    def get_inner_airgap_line(self):
+        logger.debug("begin of get_inner_airgap_line")
+        assert(self.geom.is_inner)
         assert(self.geom.area_list)
 
-        logger.debug("-- get line from %s to %s", start_node, end_node)
+        area = [a for a in self.geom.area_list if a.close_to_ag_endcorner]
+        if len(area) != 1:
+            logger.debug("end of get_inner_airgap_line: %s areas found", len(area))
+            return [], []
 
-        logger.debug("EDGE FOUND: %s - %s", n1, n2)
-        nodes = [n1, n2]
-        info = self.get_edge_info(n1, n2)
-        elements = [info.element]
+        start_node = self.geom.end_corners[-1]
+        logger.debug("START NODE %s", start_node)
+        end_node = self.geom.start_corners[-1]
+        logger.debug("END NODE %s", end_node)
 
-        while not points_are_close(start_corner, n2):
-            info.set_start_angle()
-            info = self.next_edge_lefthand_side(info)
-            if not info:  # bad
-                return []
-            n2 = info.n2
-            nodes.append(n2)
-            elements.append(info.element)
+        return self.get_airgap_line(start_node, end_node, area[0])
 
-        logger.debug("end of get_inner_airgap_line #%s", len(nodes))
-        return nodes, elements
+    def close_outer_winding_areas(self):
+        logger.debug("close_outer_winding_areas")
+
+        airgap_line, airgap_el = self.get_outer_airgap_line()
+        logger.debug("Outer Airgap with %s Nodes", len(airgap_line))
+
+        if len(airgap_line) < 5:
+            return False
+
+        n1 = None
+        dist_n1 = 0.0
+
+        e_prev = None
+        n_prev = airgap_line[0]
+        dist_prev = distance(self.geom.center, n_prev)
+        alpha_prev = alpha_line(self.geom.center, n_prev)
+        alpha_start = alpha_prev
+
+        lines_created = 0
+        for n in airgap_line[1:]:
+            dist = distance(self.geom.center, n)
+            alpha = alpha_line(self.geom.center, n)
+            if not n1:
+                if dist > dist_prev and alpha < alpha_prev:
+                    n1 = n_prev
+                    dist_n1 = dist_prev
+            else:
+                if np.isclose(dist_n1, dist, rtol=1e-3, atol=1e-3):
+                    line = Line(Element(start=n1, end=n))
+                    if e_prev.intersect_line(line):
+                        logger.debug("___LINE NOT POSSIBLE___")
+                    else:
+                        self.geom.add_line(n1, n, color='red')
+                        lines_created += 1
+                    n1 = None
+                    dist_n1 = 0.0
+            if not n1:
+                e_prev = self.geom.get_edge_element(n_prev, n)
+            n_prev = n
+            dist_prev = dist
+            alpha_prev = alpha
+
+        return lines_created > 0
+
+    def get_outer_airgap_line(self):
+        logger.debug("begin of get_outer_airgap_line")
+        assert(self.geom.is_outer)
+        assert(self.geom.area_list)
+
+        area = [a for a in self.geom.area_list if a.close_to_ag_startcorner]
+        if len(area) != 1:
+            logger.debug("end of get_outer_airgap_line: %s areas found", len(area))
+            return [], []
+
+        start_node = self.geom.start_corners[0]
+        logger.debug("START NODE %s", start_node)
+        end_node = self.geom.end_corners[0]
+        logger.debug("END NODE %s", end_node)
+
+        return self.get_airgap_line(start_node, end_node, area[0])
 
     def create_one_area_group(self, areas):
         logger.debug("begin of create_one_area_group")

femagtools/dxfsl/conv.py

@@ -250,11 +250,6 @@ def main():
     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']))
 
 if __name__ == "__main__":
     loglevel = logging.INFO

femagtools/dxfsl/converter.py

@@ -2,6 +2,7 @@
 
 """
 import os
+import io
 from pathlib import Path
 from femagtools import __version__
 from femagtools.dxfsl.geom import Geometry
@@ -11,6 +12,7 @@ from femagtools.dxfsl.plotrenderer import PlotRenderer
 from femagtools.dxfsl.concat import Concatenation
 from femagtools.dxfsl.functions import Timer, middle_angle
 from femagtools.dxfsl.journal import Journal, getJournal
+from femagtools.dxfsl.area import TYPE_WINDINGS
 import logging
 import logging.config
 import numpy as np
@@ -160,12 +162,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()
@@ -175,15 +181,25 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
     else:
         machine_temp = machine
 
-    midangle = middle_angle(machine_temp.startangle,
-                            machine_temp.endangle)
-
     plot_geom(False,  # for developer
               plt, machine_temp.geom,
-              title="Inner Rotor check magnets {}".format(midangle))
+              title="Inner Rotor check magnets")
+
+    machine_slice = machine_temp.get_forced_magnet_slice()
+    if machine_slice:
+        plot_geom(False,  # for developer
+                  plt, machine_slice.geom,
+                  title="Rotor Magnet Slice")
+
+        machine_temp = machine_slice
+        machine_temp.geom.set_rotor()
+        machine_temp.rebuild_subregions(EESM, single=single)
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Rotor Magnet Slice after Rebuild")
 
     rebuild = False
-    if machine_temp.geom.magnets_in_the_middle(midangle):
+    if machine_temp.has_magnets_in_the_middle():
         logger.debug("Magnets cut")
         rebuild = machine_temp.create_mirror_lines_outside_magnets()
     else:
@@ -194,7 +210,7 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
         else:
             rebuild = machine_temp.create_mirror_lines_outside_magnets()
     if rebuild:
-        machine_temp.geom.area_list = []
+        machine_temp.geom.create_list_of_areas(delete=True)
 
     if machine_temp.create_auxiliary_lines():
         logger.debug("Auxiliary Lines created: rebuild subregions")
@@ -207,25 +223,34 @@ 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.is_mirrored():
         plot_geom(False,  # for developer
                   plt, machine.previous_machine.geom,
-                  title="Mirrored Stator",
-                  areas=True)
+                  title="Mirrored Stator")
 
         logger.debug("undo mirrored windings")
         machine_temp = machine.undo_mirror()
@@ -240,25 +265,50 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
     else:
         machine_temp = machine
 
-    rebuild = machine_temp.create_auxiliary_lines()
     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",
-                  areas=False)
-        rebuild = True
-    if rebuild:
+                  title="Nodes reduced")
+
+    machine_slice = machine_temp.get_forced_winding_slice()
+    if machine_slice:
+        plot_geom(False,  # for developer
+                  plt, machine_slice.geom,
+                  title="Stator Winding Slice")
+
+        machine_temp = machine_slice
+        machine_temp.geom.set_stator()
         machine_temp.rebuild_subregions(EESM, single=single)
+        if machine_temp.has_windings_in_the_middle():
+            machine_temp.create_mirror_lines_outside_windings()
+
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Stator Winding Slice after Rebuild")
+
+    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 Boundary 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
 
@@ -290,6 +340,7 @@ def convert(dxfile,
             full_model=False,
             debug_mode=False,
             write_journal=False):
+    global journal
     layers = ()
     conv = {}
 
@@ -816,10 +867,19 @@ 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)
@@ -840,30 +900,29 @@ def create_femag_parameters(m_inner, m_outer, nodedist=1):
     parts_inner = int(m_inner.get_symmetry_part())
     parts_outer = int(m_outer.get_symmetry_part())
 
-    slot_area = 0
-    if parts_inner > parts_outer:
-        from .area import TYPE_WINDINGS
-        slot_area = geom_inner.area_size_of_type(TYPE_WINDINGS)
-        num_slots = int(parts_inner)
-        num_poles = int(parts_outer)
-        num_sl_gen = int(geom_inner.get_symmetry_copies()+1)
-        alfa_slot = geom_inner.get_alfa()
-        alfa_pole = geom_outer.get_alfa()
+    if m_inner.geom.is_rotor():
+        geom_slots = geom_outer
+        geom_poles = geom_inner
+        num_slots = int(m_outer.get_symmetry_part())
+        num_poles = int(m_inner.get_symmetry_part())
     else:
-        from .area import TYPE_WINDINGS
-        slot_area = geom_outer.area_size_of_type(TYPE_WINDINGS)
-        num_slots = int(parts_outer)
-        num_poles = int(parts_inner)
-        num_sl_gen = int(geom_outer.get_symmetry_copies()+1)
-        alfa_slot = geom_outer.get_alfa()
-        alfa_pole = geom_inner.get_alfa()
+        geom_slots = geom_inner
+        geom_poles = geom_outer
+        num_slots = int(m_inner.get_symmetry_part())
+        num_poles = int(m_outer.get_symmetry_part())
+
+    slot_area = 0
+    slot_area = geom_slots.area_size_of_type(TYPE_WINDINGS)
+    num_sl_gen = int(geom_slots.get_symmetry_copies()+1)
+    alfa_slot = geom_slots.get_alfa()
+    alfa_pole = geom_poles.get_alfa()
 
     params['tot_num_slot'] = num_slots
     params['slot_area'] = slot_area
     params['num_sl_gen'] = num_sl_gen
     params['num_poles'] = num_poles
     params['nodedist'] = nodedist
-    params['external_rotor'] = parts_inner > parts_outer
+    params['external_rotor'] = m_outer.geom.is_rotor()
     params['dy1'] = 2*geom_outer.max_radius
     params['da1'] = 2*geom_outer.min_radius
     params['da2'] = 2*geom_inner.max_radius

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,6 +162,14 @@ 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
         NDT0=1.1
@@ -228,18 +236,19 @@ class FslRenderer(object):
                     geom.start_max_corner(1)),
                 'hair = 1.0',
                 'parts = {}'.format(machine.get_num_parts()),
-                'r1 = {} + hair'.format(geom.max_radius),
+                'rmax = {}'.format(geom.max_radius),
+                'r1 = rmax + hair',
                 '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),
+                'r2 = {}'.format(geom.dist_end_max_corner(mirrored=False)),
+                'x3, y3 = pr2c(r2, {}*math.pi/parts)'.format(slice),
                 'nc_line(x0, y0, x1, y1, 0)',
                 'nc_circle_m(x1, y1, x2, y2, 0.0, 0.0, 0)',
                 'nc_line(x2, y2, x3, y3, 0)',
-                'x0, y0 = pr2c(r1 - hair/2, math.pi/parts/2)',
+                'x0, y0 = pr2c(rmax + hair/2, math.pi/parts/2)',
                 'create_mesh_se(x0, y0)',
                 '\n',
                 'outer_da_start = {}'.format(