femagtools 1.8.16__tar.gz → 1.8.18__tar.gz

{femagtools-1.8.16/src/femagtools.egg-info → femagtools-1.8.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: femagtools
-Version: 1.8.16
+Version: 1.8.18
 Summary: Python API for FEMAG
 Author-email: Ronald Tanner <tar@semafor.ch>, Dapu Zhang <dzhang@gtisoft.com>, Beat Holm <hob@semafor.ch>, Günther Amsler <amg@semafor.ch>, Nicolas Mauchle <mau@semafor.ch>
 License: Copyright (c) 2016-2023, Semafor Informatik & Energie AG, Basel
@@ -38,7 +38,7 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy
-Requires-Dist: scipy
+Requires-Dist: scipy<=1.14.1
 Requires-Dist: mako
 Requires-Dist: six
 Requires-Dist: lmfit

{femagtools-1.8.16 → femagtools-1.8.18}/pyproject.toml

@@ -23,7 +23,7 @@ classifiers = [
 ]
 dependencies = [
     'numpy',
-    'scipy',
+    'scipy<=1.14.1',  # Singular matrix C in mtpv_tmech
     'mako',
     'six',
     'lmfit',

{femagtools-1.8.16 → femagtools-1.8.18}/src/femagtools/__init__.py

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

{femagtools-1.8.16 → femagtools-1.8.18}/src/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-1.8.16 → femagtools-1.8.18}/src/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):
@@ -958,6 +976,23 @@ class Area(object):
             return False
         return True
 
+    def is_line_inside(self, p1, p2):
+        if self.is_point_inside(p1):
+            if self.is_point_inside(p2):
+                logger.debug("Border: Type of area %s is %s",
+                             self.identifier(), self.type)
+                return True
+            if self.the_point_is_inside_area(p2):
+                logger.debug("Inside: Type of area %s is %s",
+                             self.identifier(), self.type)
+                return True
+        elif self.is_point_inside(p2):
+            if self.the_point_is_inside_area(p1):
+                logger.debug("Inside: Type of area %s is %s",
+                             self.identifier(), self.type)
+                return True
+        return False
+
     def get_best_point_inside(self, geom):
         px1 = self.min_x - 5
         px2 = self.max_x + 5
@@ -1172,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:
@@ -1419,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,
@@ -1454,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 [{}] *****"
@@ -1563,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
@@ -1607,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))
@@ -1680,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))
@@ -1788,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(self, 0.0, alpha)
 
         if self.is_magnet_rectangle():
             self.type = TYPE_MAGNET_RECT  # magnet embedded
@@ -1831,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-1.8.16 → femagtools-1.8.18}/src/femagtools/dxfsl/areabuilder.py

@@ -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")
+        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))
@@ -830,24 +820,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 +934,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-1.8.16 → femagtools-1.8.18}/src/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")
@@ -202,6 +206,18 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
                   title="Rotor Magnet Slice after Rebuild")
 
     rebuild = False
+    if machine_temp.magnets_missing(EESM):
+        mag = machine_temp.looking_for_one_possible_magnet()
+        if mag:
+            if machine.is_mirrored():
+                rebuild = machine_temp.create_mirror_lines_outside_magnets()
+                if machine_temp.create_auxiliary_lines():
+                    rebuild = True
+                if rebuild:
+                    machine_temp.rebuild_subregions(EESM, single=single)
+                    machine_temp.geom.force_area_as_magnet(mag)
+            return machine_temp
+
     if machine_temp.has_magnets_in_the_middle():
         logger.debug("Magnets cut")
         rebuild = machine_temp.create_mirror_lines_outside_magnets()
@@ -246,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")
 
@@ -432,10 +452,10 @@ def convert(dxfile,
             return dict(error='unknown location {}'.format(part[1]))
     else:
         if da:
-            logger.warn("distance airgap (da) ignored")
+            logger.warning("distance airgap (da) ignored")
             da = 0.0
         if dy:
-            logger.warn("distance yoke (dy) ignored")
+            logger.warning("distance yoke (dy) ignored")
             dy = 0.0
 
     split_ini = split
@@ -508,13 +528,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')
@@ -1064,7 +1084,7 @@ def create_femag_parameters_stator(motor, position):
         params['da1'] = 2*motor.geom.min_radius
     params['slot_area'] = motor.slot_area()
     params['stator'] = _create_stator_parameters(motor)
-    params['machine'] = motor
+    #params['machine'] = motor
     return params
 
 
@@ -1080,5 +1100,5 @@ def create_femag_parameters_rotor(motor, position):
         params['da1'] = 2*motor.geom.min_radius
     params['slot_area'] = motor.slot_area()
     params['rotor'] = _create_rotor_parameters(motor)
-    params['machine'] = motor
+    #params['machine'] = motor
     return params

{femagtools-1.8.16 → femagtools-1.8.18}/src/femagtools/dxfsl/fslrenderer.py

@@ -270,7 +270,7 @@ class FslRenderer(object):
         for area in geom.list_of_areas():
             if area.number_of_elements() > 1:
                 p = area.get_point_inside(geom)
-                if p:
+                if p and area.type > 0:
                     self.content.append("x0, y0 = {}, {}".format(p[0], p[1]))
                     # self.content.append("point(x0, y0, red, 4)")  # for debugging
                     self.content.append("create_mesh_se(x0, y0)")
@@ -324,7 +324,7 @@ class FslRenderer(object):
                         self.content.append(
                             'x0_shaft, y0_shaft = x0, y0')
 
-                self.content.append("\n")
+        self.content.append("create_mesh(x0, y0)\n")
 
         txt = ["if x0_iron_yoke > 0.0 then",
                "  if mcvkey_yoke ~= 'dummy' then",