femagtools 1.8.19__tar.gz → 1.8.20__tar.gz

{femagtools-1.8.19/src/femagtools.egg-info → femagtools-1.8.20}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: femagtools
-Version: 1.8.19
+Version: 1.8.20
 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

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/__init__.py

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

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/dxfsl/area.py

@@ -105,6 +105,12 @@ class Area(object):
     def elements(self):
         return self.area
 
+    def is_element_in_area(self, el):
+        for e in self.elements():
+            if el.has_same_nodes(e):
+                return True
+        return False
+
     def copy_of_elements(self):
         return [e.clone() for e in self.elements() if e]
 
@@ -1863,6 +1869,11 @@ class Area(object):
         nodes = [n for n in self.virtual_nodes(parts=4)]
         return area_size(nodes)
 
+    def get_area_size(self):
+        if self.surface == 0.0:
+            self.surface = self.area_size()
+        return self.surface
+
     def set_surface(self, mirrored):
         self.surface = self.area_size()
         if self.close_to_endangle and mirrored:

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/dxfsl/converter.py

@@ -229,7 +229,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.create_list_of_areas(delete=True)
+        machine_temp.rebuild_subregions(EESM, single=single)
 
     if machine_temp.create_auxiliary_lines():
         logger.debug("Auxiliary Lines created: rebuild subregions")
@@ -311,6 +311,9 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
                   plt, machine_temp.geom,
                   title="Stator Winding Slice after Rebuild")
 
+    if machine_temp.remove_tiny_air_areas():
+        machine_temp.rebuild_subregions(EESM, single=single)
+
     if machine_temp.create_auxiliary_lines():
         machine_temp.rebuild_subregions(EESM, single=single)
         plot_geom(False,  # for developer
@@ -1039,7 +1042,7 @@ def create_femag_parameters(m_inner, m_outer, nodedist=1):
     alfa_pole = geom_poles.get_alfa()
 
     params['tot_num_slot'] = num_slots
-    params['slot_area'] = slot_area
+    params['slot_area'] = float(slot_area)
     params['num_sl_gen'] = num_sl_gen
     params['num_poles'] = num_poles
     params['nodedist'] = nodedist

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/dxfsl/fslrenderer.py

@@ -246,6 +246,37 @@ class FslRenderer(object):
                 'outer_da_end = {}'.format(
                     geom.dist_end_min_corner())
             ]
+        if inner:
+            r = np.linalg.norm(geom.start_corners[0])
+            if not np.isclose(geom.min_radius, r, rtol=1e-3):
+                slice = 1 if machine.is_mirrored() else 2
+                self.content += [
+                    '-- create air layer inside',
+                    'x0, y0 = {}, {}'.format(
+                        geom.start_min_corner(0),
+                        geom.start_min_corner(1)),
+                    'hair = 1.0',
+                    'parts = {}'.format(machine.get_num_parts()),
+                    'rmin = {}'.format(geom.min_radius),
+                    'r1 = rmin - hair',
+                    'r, phi = c2pr(x0, y0)',
+                    'x1, y1 = pr2c(r1, phi)',
+                    'x2, y2 = pr2c(r1, {}*math.pi/parts)'.format(slice),
+                    'x3, y3 = pr2c(r, {}*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(rmin - hair/2, math.pi/parts/2)',
+                    'create_mesh_se(x0, y0)',
+                    '\n']
+            else:
+                self.content += [
+                    'parts = {}'.format(machine.get_num_parts()),
+                    'x0, y0 = {}, {}'.format(
+                        geom.start_min_corner(0),
+                        geom.start_min_corner(1)),
+                    'r1, phi = c2pr(x0, y0)']
+
         if self.mtype == 'PMSM':
             self.content += [
                          'xmag = {}',
@@ -327,7 +358,7 @@ class FslRenderer(object):
                         self.content.append(
                             'x0_shaft, y0_shaft = x0, y0')
 
-        self.content.append("create_mesh(x0, y0)\n")
+        self.content.append("create_mesh()\n")
 
         txt = ["if x0_iron_yoke > 0.0 then",
                "  if mcvkey_yoke ~= 'dummy' then",
@@ -390,22 +421,24 @@ class FslRenderer(object):
         # angle after mirroring
         self.content.append('alfa = {}\n'.format(geom.get_alfa()))
 
-        self.content += ['-- rotate',
-                         'x1, y1 = {}, {}'.format(
-                             geom.start_corners[0][0],
-                             geom.start_corners[0][1])]  # min xy1
         if outer:
-            self.content.append('x2, y2 = pr2c(r1, 0.0)')
+            self.content += ['-- rotate',
+                             'x1, y1 = {}, {}'.format(
+                                 geom.start_corners[0][0],
+                                 geom.start_corners[0][1]),  # min xy1
+                             'x2, y2 = pr2c(r1, 0.0)']
         else:
-            self.content.append('x2, y2 = {}, {}'.format(
-                geom.start_corners[1][0],
-                geom.start_corners[1][1]))  # max xy1
+            self.content += ['-- rotate',
+                             'x1, y1 = pr2c(r1, 0.0)',
+                             'x2, y2 = {}, {}'.format(
+                                 geom.start_corners[1][0],
+                                 geom.start_corners[1][1])]  # min xy1
 
         if geom.is_mirrored():
             self.content.append('x3, y3 = pr2c(x2, alfa)')
             self.content.append('x4, y4 = pr2c(x1, alfa)')
         elif outer:
-            self.content += ['x3, y3 = pr2c(r1, 2*math.pi/parts+phi)',
+            self.content += ['x3, y3 = pr2c(r1, 2*math.pi/parts)',
                              'x4, y4 = {}, {}'.format(
                                  geom.end_corners[0][0],
                                  geom.end_corners[0][1])]  # min xy4
@@ -413,10 +446,7 @@ class FslRenderer(object):
             self.content += ['x3, y3 = {}, {}'.format(
                                  geom.end_corners[-1][0],
                                  geom.end_corners[-1][1]), # min xy3
-                             'x4, y4 = {}, {}'.format(
-                                 geom.end_corners[0][0],
-                                 geom.end_corners[0][1]),  # min xy4
-                             'def_bcond_vpo(x4, y4, x1, y1)']
+                             'x4, y4 = pr2c(r1, 2*math.pi/parts)']
 
         self.content.append('if parts_gen > 1 then')
         if geom.corners_dont_match():

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/dxfsl/geom.py

@@ -4803,6 +4803,52 @@ class Geometry(object):
             return
         logger.warning("WARNING: airgap connecting nodes do not aline")
 
+    def remove_area(self, area):
+        logger.debug("Remove Area %s", area.identifier())
+        touching_areas = [(a.surface, a) for a in self.list_of_areas()
+                          if a.id != area.id and a.is_touching(area)]
+        if not touching_areas:
+            self.remove_edges(area.area)
+            return
+        touching_areas.sort(reverse=True)
+        sz, touching_a = touching_areas[0]
+        for e in area.area:
+            if touching_a.is_element_in_area(e):
+                self.remove_edge(e)
+
+    def remove_tiny_air_areas(self):
+        logger.debug("remove_tiny_air_areas()")
+        air_areas = [a for a in self.list_of_areas() if a.is_air()]
+        if not air_areas:
+            return False
+
+        def is_in_touch(air, area_list):
+            for a in area_list:
+                if air.is_touching(a):
+                    return True
+                if air.is_inside(a, self):
+                    return True
+            return False
+
+        areas = [a for a in self.list_of_areas() if a.is_winding() or a.is_magnet()]
+        if not areas:
+            return False
+
+        tiny_areas = [a for a in air_areas if not is_in_touch(a, areas)]
+        geom_surface = self.area_size()
+        angle_areas = [a for a in tiny_areas
+                      if (a.close_to_startangle or a.close_to_endangle)]
+        #inside_areas = [a for a in tiny_areas
+        #                if not (a.close_to_startangle or a.close_to_endangle) and \
+        #                   a.get_area_size() < geom_surface / 200]
+        tiny_areas = angle_areas
+        if not tiny_areas:
+            return False
+
+        for a in tiny_areas:
+            self.remove_area(a)
+        return True
+
     def print_nodes(self):
         print("=== List of Nodes ({}) ===".format(self.number_of_nodes()))
         for n in self.g.nodes():

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/dxfsl/machine.py

@@ -1590,3 +1590,9 @@ class Machine(object):
         self.geom.check_airgap_connecting_nodes(m_outer.geom,
                                                 self.startangle,
                                                 self.endangle)
+
+    def remove_tiny_air_areas(self):
+        if not self.geom.remove_tiny_air_areas():
+            return False
+        self.repair_hull()
+        return True

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/dxfsl/shape.py

@@ -90,6 +90,13 @@ class Shape(object):
             self.n2 = n1
             self.n1 = n2
 
+    def has_same_nodes(self, e):
+        if points_are_close(e.n1, self.n1):
+            return points_are_close(e.n2, self.n2)
+        if points_are_close(e.n1, self.n2):
+            return points_are_close(e.n2, self.n1)
+        return False
+
     """an abstract geometry with 2 points"""
 
     def start(self):

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/femag.py

@@ -424,7 +424,7 @@ class BaseFemag(object):
         return sorted(pathlib.Path(self.workdir).glob('*.PROT'),
                       key=lambda x: x.stat().st_mtime, reverse=True)[0].stem
 
-    def readResult(self, machine, simulation, bch=None):
+    def readResult(self, simulation, bch=None, machine=None):
         if simulation:
             if simulation['calculationMode'] == "fieldcalc":
                 nc = self.read_nc()
@@ -656,7 +656,7 @@ class Femag(BaseFemag):
             pass
 
         if simulation:
-            return self.readResult(machine, simulation)
+            return self.readResult(machine=machine, simulation=simulation)
 
         return {'status': 'ok', 'message': self.modelname,
                 'model': self.model.props()}
@@ -1196,6 +1196,6 @@ class ZmqFemag(BaseFemag):
         if r['status'] == 'ok':
             bch = femagtools.bch.Reader()
             bch.read(content.decode('latin1'))
-            bch = self.readResult(simulation, bch)
+            bch = self.readResult(simulation=simulation, bch=bch)
             return bch
         raise FemagError(r['message'])

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/machine/pm.py

@@ -181,9 +181,10 @@ class PmRelMachine(object):
         if np.abs(torque) < 1e-2:
             return (0, 0)
         if np.isscalar(iqd0):
-            i0 = self.io
+            i0 = list(self.io)
             if torque<0:
                 i0[0] = -i0[0]
+                i0 = tuple(i0)
         else:
             i0 = iqd0
         if with_mtpa:

{femagtools-1.8.19 → femagtools-1.8.20}/src/femagtools/model.py

@@ -477,8 +477,14 @@ class MachineModel(Model):
         model = {k: getattr(self, k) for k in keys if hasattr(self, k)}
         if hasattr(self, 'stator'):
             model['stator'] = {k: self.stator[k]
-                               for k in ('num_slots', 'num_slots_gen', 'slot_area')
+                               for k in ('num_slots',
+                                         'num_slots_gen',
+                                         'slot_area')
                                if k in self.stator}
+
+        for k in model:
+            if isinstance(model[k], np.float64):
+                model[k] = float(model[k])
         return model
 
 class FeaModel(Model):

{femagtools-1.8.19 → femagtools-1.8.20/src/femagtools.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: femagtools
-Version: 1.8.19
+Version: 1.8.20
 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