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

femagtools/__init__.py

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

femagtools/dxfsl/area.py

@@ -12,6 +12,7 @@ import numpy as np
 import networkx as nx
 import logging
 from .functions import less_equal, less, greater_equal, greater
+from .functions import greater_angle, less_angle
 from .functions import distance, alpha_angle, alpha_line, min_angle, max_angle
 from .functions import point, line_m, line_n, intersect_point, points_are_close
 from .functions import middle_angle, part_of_circle, is_same_angle
@@ -75,6 +76,10 @@ class Area(object):
         self.start = 0.0
         self.sym_startangle = 0.0
         self.sym_endangle = 0.0
+        self.sym_upper_left_dist = None
+        self.sym_upper_right_dist = None
+        self.sym_lower_left_dist = None
+        self.sym_lower_right_dist = None
         self.sym_type = 0
         self.symmetry = 0
         self.sym_tolerance = sym_tolerance
@@ -100,6 +105,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
@@ -671,6 +679,66 @@ class Area(object):
             return True
         return False
 
+    def set_symmetry_parameter(self, center):
+        all_list = [(distance(center, n), alpha_line(center, n))
+                    for n in self.list_of_nodes()]
+        mid = middle_angle(self.min_angle, self.max_angle)
+        left_list = [(d, a) for d, a in all_list if greater_angle(a, mid)]
+        right_list = [(d, a) for d, a in all_list if less_angle(a, mid)]
+        left_list.sort()
+        right_list.sort()
+
+        if left_list:
+            l_low_d, l_low_a = left_list[0]
+            l_up_d, l_up_a = left_list[-1]
+        else:
+            l_low_d = self.min_dist
+            l_up_d = self.max_dist
+        if right_list:
+            r_low_d, r_low_a = right_list[0]
+            r_up_d, r_up_a = right_list[-1]
+        else:
+            r_low_d = self.min_dist
+            r_up_d = self.max_dist
+        self.sym_upper_left_dist = l_up_d
+        self.sym_upper_right_dist = r_up_d
+        self.sym_lower_left_dist = l_low_d
+        self.sym_lower_right_dist = r_low_d
+
+    def is_symmetry_equal(self, area):
+        logger.debug("check area %s -- %s", self.get_id(), area.get_id())
+
+        bad = False
+        if not np.isclose(self.sym_lower_left_dist, area.sym_lower_left_dist,
+                           rtol=5e-1, atol=5e-1):
+            logger.debug("Lower left: %s != %s",
+                         self.sym_lower_left_dist,
+                         area.sym_lower_left_dist)
+            bad = True
+
+        if not np.isclose(self.sym_lower_right_dist, area.sym_lower_right_dist,
+                          rtol=5e-1, atol=5e-1):
+            logger.debug("Lower right: %s != %s",
+                         self.sym_lower_right_dist,
+                         area.sym_lower_right_dist)
+            bad = True
+
+        if not np.isclose(self.sym_upper_left_dist, area.sym_upper_left_dist,
+                          rtol=5e-1, atol=5e-1):
+            logger.debug("Upper left: %s != %s",
+                         self.sym_upper_left_dist,
+                         area.sym_upper_left_dist)
+            bad = True
+
+        if not np.isclose(self.sym_upper_right_dist, area.sym_upper_right_dist,
+                          rtol=5e-1, atol=5e-1):
+            logger.debug("Upper right: %s != %s",
+                         self.sym_upper_right_dist,
+                         area.sym_upper_right_dist)
+            bad = True
+
+        return not bad
+
     def increment(self, a):
         if self.is_identical(a):
             return
@@ -1208,6 +1276,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 +1285,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 +1394,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 +1890,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

@@ -115,6 +115,10 @@ def main():
                            help='create fsl',
                            dest='write_fsl',
                            action="store_true")
+    argparser.add_argument('--fsl_single',
+                           help='create separate fsl for rotor and stator',
+                           dest='write_fsl_single',
+                           action="store_true")
     argparser.add_argument('-v', '--view',
                            help='show a view only',
                            dest='view',
@@ -242,6 +246,7 @@ def main():
                   show_areas=args.show_areas,
                   small_plots=args.small_plots,
                   write_fsl=args.write_fsl,
+                  write_fsl_single=args.write_fsl_single,
                   write_png=args.write_png,
                   write_id=args.write_id,
                   debug_mode=args.debugger,

femagtools/dxfsl/converter.py

@@ -12,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
@@ -180,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:
@@ -199,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")
@@ -239,8 +250,7 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
     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()
@@ -261,6 +271,22 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
                   plt, machine_temp.geom,
                   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
@@ -273,7 +299,7 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
     if not machine_temp.is_mirrored():
         plot_geom(False,  # for developer
                   plt, machine_temp.geom,
-                  title="Stator before Boundery Corr")
+                  title="Stator before Boundary Corr")
         machine_temp.create_boundary_nodes()
 
     plot_geom(False,  # for developer
@@ -309,6 +335,7 @@ def convert(dxfile,
             show_areas=False,
             small_plots=False,
             write_fsl=True,
+            write_fsl_single=False,
             write_png=False,
             write_id=False,
             full_model=False,
@@ -362,6 +389,9 @@ def convert(dxfile,
         split_ini = False
         split_cpy = split
 
+    if write_fsl_single:
+        write_fsl = True
+
     try:
         if input_file.suffix in ['.fem', '.FEM']:
             from .femparser import femshapes
@@ -693,6 +723,14 @@ def convert(dxfile,
             fslrenderer = FslRenderer(basename, mtype)
             inner = fslrenderer.render(machine_inner, inner=True)
             outer = fslrenderer.render(machine_outer, outer=True)
+            if write_fsl_single:
+                inner_single = fslrenderer.render(machine_inner, inner=True,
+                                                  standalone=True)
+                outer_single = fslrenderer.render(machine_outer, outer=True,
+                                                  standalone=True)
+            else:
+                inner_single = None
+                outer_single = None
             if full_model:
                 params['num_sl_gen'] = params.get('tot_num_slot', 0)
             params['agndst'] = agndst(params.get('da1'),
@@ -703,10 +741,18 @@ def convert(dxfile,
 
             if params['external_rotor']:
                 conv['fsl_rotor'] = outer
+                if outer_single:
+                    conv['fsl_rotor_single'] = outer_single
                 conv['fsl_stator'] = inner
+                if inner_single:
+                    conv['fsl_stator_single'] = inner_single
             else:
                 conv['fsl_rotor'] = inner
+                if inner_single:
+                    conv['fsl_rotor_single'] = inner_single
                 conv['fsl_stator'] = outer
+                if outer_single:
+                    conv['fsl_stator_single'] = outer_single
 
             conv['fsl'] = fslrenderer.render_main(
                 machine_inner, machine_outer,
@@ -849,11 +895,24 @@ def convert(dxfile,
     if write_fsl:
         logger.debug("Write fsl")
         if conv and conv['fsl']:
-            with io.open(basename + '.fsl', 'w', encoding='utf-8') as f:
+            with io.open(basename + '.fsl', 'w',
+                         encoding='utf-8') as f:
                 f.write('\n'.join(conv['fsl']))
         else:
             logger.warning("No fsl data available")
 
+        if conv:
+            if conv.get('fsl_rotor_single', None):
+                with io.open(basename + '_ROTOR.fsl', 'w',
+                             encoding='utf-8') as f:
+                    f.write('\n'.join(conv['fsl_rotor_single']))
+                del conv['fsl_rotor_single']
+            if conv.get('fsl_stator_single', None):
+                with io.open(basename + '_STATOR.fsl', 'w',
+                             encoding='utf-8') as f:
+                    f.write('\n'.join(conv['fsl_stator_single']))
+                del conv['fsl_stator_single']
+
     conv['name'] = basename
     t = timer.stop("-- all done in %0.4f seconds --", info=True)
     journal.put('time_total', t)
@@ -874,30 +933,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

@@ -236,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(