femagtools 1.8.17__py3-none-any.whl → 1.8.19__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.17'
+__version__ = '1.8.19'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2025 Gamma Technology'

femagtools/airgap.py

@@ -24,7 +24,11 @@ def fft(pos: list, b: list, pmod=0) -> dict:
     Bamp = r['a']
     alfa0 = r['alfa0']
     T0 = r['T0']
-    npoles = 2*round(360/T0)
+    try:
+        npoles = 2*round(360/T0)
+    except ZeroDivisionError:
+        npoles=0
+        pass
     logger.info("flux density: %s poles B amp %f ",
                 npoles, r['a'])
     return dict(Bamp=Bamp, npoles=npoles,

femagtools/bch.py

@@ -271,7 +271,7 @@ class Reader:
             return self.flux[0]['displ'][1]-self.flux[0]['displ'][0]
         return None
 
-    def read(self, content):
+    def read(self, content, **kwargs):
         """read bch file
 
         Args:
@@ -297,7 +297,10 @@ class Reader:
                     if k == title2[:len(k)]:
                         title = title2[:len(k)]
             if title in self.dispatch:
-                self.dispatch[title](self, s)
+                if title == 'Airgap Induction Br':
+                    self.dispatch[title](self, s, kwargs.get('ignore_airgap_induction_with_c_step_section', True))
+                else:
+                    self.dispatch[title](self, s)
 
         if len(self.weights) > 0:
             w = list(zip(*self.weights))
@@ -887,7 +890,7 @@ class Reader:
             self.flux_fft[self.wdg] = []
         self.flux_fft[self.wdg].append(flux_fft)
 
-    def __read_airgapInduction(self, content):
+    def __read_airgapInduction(self, content, ignore_c_step_section=True):
         "read and append airgapInduction section"
         import scipy.integrate as si
         import math
@@ -918,7 +921,9 @@ class Reader:
                 i1beta = True
                 continue
             if line.startswith("C_STEP"):
-                return   # ignore this section
+                if ignore_c_step_section:
+                    return  # ignore this section
+                continue
             try:
                 rec = self.__findNums(line)
                 if len(rec) == 10:
@@ -966,6 +971,10 @@ class Reader:
             self.airgapInduction['iq'] = iq
             self.airgapInduction['id'] = id
             nrows = len(self.airgapInduction['id'])
+        if not ignore_c_step_section:
+            # min 1 required (section with C_STEP)
+            nrows = max(1, nrows)
+            ncols = max(1, ncols)
 
         try:
             self.airgapInduction['an'] = [np.reshape(an[j][:nrows*ncols],
@@ -999,6 +1008,14 @@ class Reader:
                                                      [1:])
                     self.airgapInduction['Bm'] = zip(*zip(*self.airgapInduction['Bm'])
                                                      [1:])
+            elif not ignore_c_step_section:
+                # section with C_STEP and a single data linex
+                self.airgapInduction['an'] = [self.airgapInduction['an'][i][0:]
+                                              for i in range(4)]
+                self.airgapInduction['bn'] = [self.airgapInduction['bn'][i][0:]
+                                              for i in range(4)]
+                self.airgapInduction['Ba'] = self.airgapInduction['Ba'][0:]
+                self.airgapInduction['Bm'] = self.airgapInduction['Bm'][0:]
         except ValueError:
             print(self.airgapInduction['i1'])
 
@@ -1858,12 +1875,12 @@ class Reader:
         return self.__str__()
 
 
-def read(filename):
+def read(filename, **kwargs):
     """Read BCH/BATCH results from file *filename*."""
     import io
     bchresults = Reader()
     with io.open(filename, encoding='latin1', errors='ignore') as f:
-        bchresults.read(f.readlines())
+        bchresults.read(f.readlines(), **kwargs)
     return bchresults
 
 

femagtools/dxfsl/area.py

@@ -475,6 +475,19 @@ class Area(object):
 
         self.alpha = round(alpha_angle(self.min_angle, self.max_angle), 3)
 
+    def set_close_to_start_end_angles(self, startangle, endangle):
+        logger.debug("set_close_to_start_end_angles(%s, %s)",startangle, endangle)
+        logger.debug(">> %s: min/max = %s/%s", self.identifier(), self.min_angle, self.max_angle)
+        if np.isclose(startangle, endangle):  # full
+            self.close_to_startangle = True
+            self.close_to_endangle = True
+            return
+
+        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)
+
     def center_is_inside(self, center):
         if less(self.min_x, center[0], rtol=1e-03, atol=1e-04) and \
            greater(self.max_x, center[0], rtol=1e-03, atol=1e-04) and \
@@ -552,12 +565,17 @@ class Area(object):
         return (self.close_to_startangle and self.close_to_endangle)
 
     def is_in_touch_with_area(self, geom, a):
+        if self.is_one_circle_element():
+            return False
+        if a.is_one_circle_element():
+            return False
+
         n1 = self.area[0].n1
         n2 = a.area[0].n2
         try:
             return nx.has_path(geom.g, n1, n2)
-        except nx.NetworkXError:
-            logger.warning("has_path() failed")
+        except nx.NetworkXError as e:
+            logger.warning("has_path() failed: %s", e)
             return False
 
     def has_connection(self, geom, a, ndec):
@@ -1189,6 +1207,11 @@ class Area(object):
                 continue
         return r
 
+    def is_one_circle_element(self):
+        if len(self.area) == 1:
+            return is_Circle(self.area[0])
+        return False
+
     def is_circle(self):
         e = self.area[0]
         if len(self.area) == 1:
@@ -1436,11 +1459,7 @@ class Area(object):
             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.set_close_to_start_end_angles(startangle, endangle)
         self.surface = self.area_size()
 
     def mark_stator_subregions(self,
@@ -1471,10 +1490,7 @@ class Area(object):
             opposite_radius = r_out
             airgap_toleranz = (self.max_dist - self.min_dist) / 50.0  # 2%
 
-        self.close_to_startangle = np.isclose(self.min_angle, 0.0,
-                                              1e-04, 1e-04)
-        self.close_to_endangle = np.isclose(self.max_angle, alpha,
-                                            1e-04, 1e-04)
+        self.set_close_to_start_end_angles(0.0, alpha)
         self.surface = self.area_size()
 
         logger.debug("\n***** mark_stator_subregions [{}] *****"
@@ -1580,7 +1596,10 @@ class Area(object):
             logger.debug("***** air #3")
 
         if self.close_to_startangle or self.close_to_endangle:
-            f = self.surface / stator_size
+            if stator_size > 0.0:
+                f = self.surface / stator_size
+            else:
+                f = 0.0
             if f < 0.02:  # area_size less then 2 percent of stator size
                 # Luftloch
                 self.type = TYPE_AIR  # air
@@ -1624,10 +1643,7 @@ class Area(object):
             opposite_radius = r_out
             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.set_close_to_start_end_angles(startangle, endangle)
 
         logger.debug("\n***** mark_EESM_rotor_subregions [{}] *****"
                      .format(self.id))
@@ -1697,10 +1713,7 @@ class Area(object):
             opposite_radius = r_out
             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.set_close_to_start_end_angles(startangle, endangle)
 
         logger.debug("\n***** mark_PMSM_rotor_subregions [{}] *****"
                      .format(self.id))
@@ -1805,8 +1818,7 @@ class Area(object):
             logger.debug(">>> air is a circle")
             return self.type
 
-        self.close_to_startangle = np.isclose(self.min_angle, 0.0)
-        self.close_to_endangle = np.isclose(self.max_angle, alpha)
+        self.set_close_to_start_end_angles(0.0, alpha)
 
         if self.is_magnet_rectangle():
             self.type = TYPE_MAGNET_RECT  # magnet embedded
@@ -1848,7 +1860,7 @@ class Area(object):
                 return 0.0
             return np.pi * e.radius**2
 
-        nodes = [n for n in self.list_of_nodes()]
+        nodes = [n for n in self.virtual_nodes(parts=4)]
         return area_size(nodes)
 
     def set_surface(self, mirrored):

femagtools/dxfsl/areabuilder.py

@@ -16,7 +16,7 @@ from femagtools.dxfsl.area import Area, TYPE_AIR
 from femagtools.dxfsl.functions import points_are_close, nodes_are_equal, distance
 from femagtools.dxfsl.functions import normalise_angle, positive_angle, point
 from femagtools.dxfsl.functions import alpha_line, alpha_points, alpha_angle
-from femagtools.dxfsl.functions import less, is_same_angle
+from femagtools.dxfsl.functions import less, less_equal, greater, is_same_angle
 from femagtools.dxfsl.functions import Timer
 from femagtools.dxfsl.journal import getJournal
 import io
@@ -135,7 +135,7 @@ class EdgeInfo(object):
         self.angle = positive_angle(alpha_angle(start_angle, self.n1_angle_ingoing()))
         logger.debug("set_direction_angle: angle is %s", self.angle)
 
-        if is_same_angle(0.0, self.angle, atol=0.008):  # 1/2 degree
+        if is_same_angle(0.0, self.angle, atol=0.015):  # 1/2 degree
             # reverse direction
             logger.debug("set_direction_angle: reverse direction( nearly 180 degrees)")
 
@@ -218,7 +218,7 @@ class EdgeInfo(object):
         myself_angle = self.angle
         other_angle = nbr_edge.angle
 
-        if is_same_angle(0.0, myself_angle):
+        if is_same_angle(0.0, myself_angle, atol=0.015):
             # 360 or 0 degrees => turn 180 degrees
             logger.debug("-- ATTENTION: myself %s turns nearly 180 degrees", self.classname())
             logger.debug("   the angle is %s", myself_angle)
@@ -261,7 +261,7 @@ class EdgeInfo(object):
                         logger.debug("#4: end of myself_direction_lefthand: ==> %s", left)
                         return left
 
-        if is_same_angle(0.0, other_angle, atol=0.008):  # 1/2 degree
+        if is_same_angle(0.0, other_angle, atol=0.015):  # 1/2 degree
             # 360 or 0 degrees => turn 180 degrees
             logger.debug("-- ATTENTION: other %s turns nearly 180 degrees", nbr_edge.classname())
             logger.debug("   the angle is %s", other_angle)
@@ -288,7 +288,7 @@ class EdgeInfo(object):
 
         logger.debug("-- angles: myself = %s,  other = %s",
                      myself_angle, other_angle)
-        if not is_same_angle(myself_angle, other_angle, atol=0.008):  # 1/2 degree
+        if not is_same_angle(myself_angle, other_angle, atol=0.015):  # 1/2 degree
             logger.debug("-- angles are different")
             left = myself_angle > other_angle
             log_lefthand(left, self, nbr_edge)
@@ -730,31 +730,12 @@ class AreaBuilder(object):
         logger.debug("end of create_inner_corner_auxiliary_areas")
         return created
 
-    def get_airgap_line(self, start_node, end_node, area):
+    def get_airgap_line(self, n1, n2, end_node):
         logger.debug("get_airgap_line")
 
         self.set_edge_attributes()
 
-        nodes = [n for n in area.list_of_nodes()]
-        if not nodes:
-            logger.debug("end of get_airgap_line: no nodes found")
-            return [], []
-
-        n1 = nodes[0]
-        if points_are_close(start_node, n1):
-            n2 = nodes[-1]
-        else:
-            n2 = n1
-            for n1 in nodes[1:]:
-                if points_are_close(start_node, n1):
-                    break
-                n2 = n1
-
-        if not points_are_close(start_node, n1):
-            logger.debug("end of get_airgap_line: not close to start-node")
-            return [], []
-
-        logger.debug("START EDGE FOUND: %s - %s", n1, n2)
+        logger.debug("START EDGE IS: %s - %s", n1, n2)
         nodes = [n1, n2]
         info = self.get_edge_info(n1, n2)
         elements = [info.element]
@@ -768,28 +749,37 @@ class AreaBuilder(object):
             nodes.append(n2)
             elements.append(info.element)
 
-        logger.debug("end of get_airgap_line #%s", len(nodes))
+        logger.debug("end of get_airgap_line: %s nodes", len(nodes))
         return nodes, elements
 
+    def get_upper_border_line(self):
+        start_node = self.geom.end_corners[-1]
+        end_node = self.geom.start_corners[-1]
+        next_node = self.get_right_neighbor(start_node)
+        logger.debug("UPPER NODES start=%s, next=%s, end=%s", start_node, next_node, end_node)
+        return self.get_airgap_line(start_node, next_node, end_node)
+
+    def get_lower_border_line(self):
+        start_node = self.geom.start_corners[0]
+        end_node = self.geom.end_corners[0]
+        next_node = self.get_left_neighbor(start_node)
+        logger.debug("LOWER NODES start=%s, next=%s, end=%s", start_node, next_node, end_node)
+        return self.get_airgap_line(start_node, next_node, end_node)
+
     def get_inner_airgap_line(self):
-        logger.debug("begin of get_inner_airgap_line")
+        logger.debug("get_inner_airgap_line()")
         assert(self.geom.is_inner)
         assert(self.geom.area_list)
+        return self.get_upper_border_line()
 
-        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 [], []
-
-        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)
-
-        return self.get_airgap_line(start_node, end_node, area[0])
+    def get_inner_opposite_airgap_line(self):
+        logger.debug("get_inner_opposite_airgap_line()")
+        assert(self.geom.is_inner)
+        assert(self.geom.area_list)
+        return self.get_lower_border_line()
 
-    def close_outer_winding_areas(self):
-        logger.debug("close_outer_winding_areas")
+    def close_outer_winding_areas(self, color='red'):
+        logger.debug("begin close_outer_winding_areas")
 
         airgap_line, airgap_el = self.get_outer_airgap_line()
         logger.debug("Outer Airgap with %s Nodes", len(airgap_line))
@@ -797,6 +787,15 @@ class AreaBuilder(object):
         if len(airgap_line) < 5:
             return False
 
+        distlist = [distance(self.geom.center, n) for n in airgap_line]
+        min_dist = min(distlist)
+        max_dist = max(distlist)
+        geom_height = self.geom.max_radius - self.geom.min_radius
+        line_height = max_dist - min_dist
+        if line_height < geom_height * 0.2:
+            return 0
+
+        logger.debug("NODES: %s TO %s", airgap_line[0], airgap_line[-1])
         n1 = None
         dist_n1 = 0.0
 
@@ -805,22 +804,29 @@ class AreaBuilder(object):
         dist_prev = distance(self.geom.center, n_prev)
         alpha_prev = alpha_line(self.geom.center, n_prev)
         alpha_start = alpha_prev
-
         lines_created = 0
+        dist_ag = self.geom.min_radius
+        logger.debug("MIN RADIUS DIST: %s",dist_ag)
         for n in airgap_line[1:]:
             dist = distance(self.geom.center, n)
             alpha = alpha_line(self.geom.center, n)
+            logger.debug("Node %s, dist=%s, alpha=%s", n, dist, alpha)
             if not n1:
-                if dist > dist_prev and alpha < alpha_prev:
-                    n1 = n_prev
-                    dist_n1 = dist_prev
+                logger.debug("Previous, dist=%s, alpha=%s", dist_prev, alpha_prev)
+                if greater(dist_prev, dist_ag, rtol=1e-3, atol=1e-3):
+                    if greater(dist, dist_prev, rtol=1e-3, atol=1e-3) and \
+                       less(alpha, alpha_prev, rtol=1e-4, atol=1e-5):
+                        n1 = n_prev
+                        dist_n1 = dist_prev
+                        logger.debug("NODE1: %s  (%s)", n1, dist_n1)
             else:
-                if np.isclose(dist_n1, dist, rtol=1e-3, atol=1e-3):
+                if less_equal(dist, dist_n1, rtol=1e-3, atol=1e-2):
+                    logger.debug("NODE2: %s  (%s)", n, dist)
                     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')
+                        self.geom.add_line(n1, n, color=color)
                         lines_created += 1
                     n1 = None
                     dist_n1 = 0.0
@@ -830,24 +836,53 @@ class AreaBuilder(object):
             dist_prev = dist
             alpha_prev = alpha
 
+        logger.debug("end close_outer_winding_areas: lines=%s", lines_created)
         return lines_created > 0
 
+    def get_left_neighbor(self, start_node):
+        nbrs = self.geom.get_neighbors(start_node)
+        start_alpha = normalise_angle(alpha_line(start_node, self.geom.center))
+        next_angle = 0.0
+        next_node = None
+        for n in nbrs:
+            alpha = normalise_angle(alpha_line(start_node, n))
+            angle = alpha_angle(start_alpha, alpha)
+            if angle > next_angle:
+                next_angle = angle
+                next_node = n
+
+        logger.debug("Left neighbor is %s", next_node)
+        return next_node
+
+    def get_right_neighbor(self, start_node):
+        nbrs = self.geom.get_neighbors(start_node)
+        start_alpha = normalise_angle(alpha_line(start_node, self.geom.center))
+        next_angle = 99
+        next_node = None
+        for n in nbrs:
+            alpha = normalise_angle(alpha_line(start_node, n))
+            angle = alpha_angle(start_alpha, alpha)
+            if angle < next_angle:
+                next_angle = angle
+                next_node = n
+
+        logger.debug("Right neighbor is %s", next_node)
+        return next_node
+
     def get_outer_airgap_line(self):
-        logger.debug("begin of get_outer_airgap_line")
+        logger.debug("get_outer_airgap_line()")
         assert(self.geom.is_outer)
         assert(self.geom.area_list)
+        return self.get_lower_border_line()
 
-        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)
+    def get_outer_opposite_airgap_line(self):
+        logger.debug("get_outer_opposite_airgap_line()")
+        assert(self.geom.is_outer)
+        assert(self.geom.area_list)
+        return self.get_upper_border_line()
 
-        return self.get_airgap_line(start_node, end_node, area[0])
+        # same procedure as inner airgap line
+        return self.get_inner_airgap_line()
 
     def create_one_area_group(self, areas):
         logger.debug("begin of create_one_area_group")
@@ -915,9 +950,13 @@ class AreaBuilder(object):
         max_x = 0
         area = None
         for a in area_list:
+            if a.is_one_circle_element():
+                continue
             if a.max_x > max_x:
                 max_x = a.max_x
                 area = a
+        if area is None:
+            return False
 
         x0, y0 = -9999.0, 0.0
         for x, y in area.list_of_nodes():

femagtools/dxfsl/converter.py

@@ -168,6 +168,10 @@ def symmetry_search(machine,
 def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
     logger.debug("Begin of build_machine_rotor")
 
+    if machine.part == 1:
+        logger.error("Full machine rotor without symmetrylines")
+        sys.exit(1)
+
     if machine.has_windings():
         logger.debug("do nothing here with windings in rotor")
         logger.debug("End of build_machine_rotor")
@@ -258,6 +262,10 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
     logger.debug("Begin of build_machine_stator")
     timer = Timer(start_it=True)
 
+    if machine.part == 1:
+        logger.error("Full stator without symmetrylines")
+        sys.exit(1)
+
     if not machine.geom.is_stator():
         logger.debug("Rotor with windings")
 
@@ -278,6 +286,8 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
             machine_temp.create_mirror_lines_outside_windings()
     else:
         machine_temp = machine
+        if machine_temp.has_windings_in_the_middle():
+            machine_temp.create_mirror_lines_outside_windings()
 
     if machine_temp.geom.reduce_element_nodes(mindist):
         machine_temp.rebuild_subregions(EESM, single=single)
@@ -520,13 +530,13 @@ def convert(dxfile,
               p, basegeom,
               title="Before finding Machine")
 
-    machine_base = basegeom.get_machine()
     if show_plots:
         p.render_elements(basegeom, Shape,
                           title=input_file.name,
                           with_hull=False,
                           rows=3, cols=2, num=1, show=debug_mode)
 
+    machine_base = basegeom.get_machine()
     if not machine_base.is_a_machine():
         logger.warn("it's Not a Machine")
         return dict(error='machine not detected')

femagtools/dxfsl/fslrenderer.py

@@ -256,6 +256,9 @@ class FslRenderer(object):
                          'if mcvkey_yoke == nil then',
                          '  mcvkey_yoke = "dummy"',
                          '  ur = 1000.0',
+                         ' else if mcvkey_teeth == nil then',
+                         ' mcvkey_teeth = mcvkey_yoke',
+                         'end',
                          'end',
                          'x0_iron_tooth, y0_iron_tooth = 0.0, 0.0',
                          'x0_iron_yoke, y0_iron_yoke = 0.0, 0.0',