femagtools 1.7.6__py3-none-any.whl → 1.7.8__py3-none-any.whl

femagtools/__init__.py

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

femagtools/bch.py

@@ -62,9 +62,12 @@ def sttylosses(losses):
             d['stteeth'] = losses[teeth]
         try:
             d['styoke_hyst'] = losses[yoke+'_hyst']
-            d['stteeth_hyst'] = losses[teeth+'_hyst']
             d['styoke_eddy'] = losses[yoke+'_eddy']
+            d['stteeth_hyst'] = losses[teeth+'_hyst']
             d['stteeth_eddy'] = losses[teeth+'_eddy']
+        except KeyError:
+            pass
+        try:
             d['styoke_excess'] = losses[yoke+'_excess']
             d['stteeth_excess'] = losses[teeth+'_excess']
         except KeyError:
@@ -306,6 +309,13 @@ class Reader:
                      'torque': tq.tolist()}]
         except (KeyError, IndexError):
             pass
+        
+        # check number of phases
+        try: 
+            if 'm' not in self.machine:
+                self.machine['m'] = len(self.current_angles)
+        except: 
+            pass
 
         return self
 

femagtools/dxfsl/converter.py

@@ -640,7 +640,8 @@ def convert(dxfile,
                 logger.warning("it's not possible to create fsl-file")
                 return None
 
-            fslrenderer = FslRenderer(basename)
+            mtype = 'EESM' if EESM else 'PMSM'
+            fslrenderer = FslRenderer(basename, mtype)
             inner = fslrenderer.render(machine_inner, inner=True)
             outer = fslrenderer.render(machine_outer, outer=True)
             if full_model:
@@ -652,14 +653,13 @@ def convert(dxfile,
                                       params.get('nodedist'))
 
             if params['external_rotor']:
-                conv['fsl_magnet'] = outer
+                conv['fsl_rotor'] = outer
                 conv['fsl_stator'] = inner
             else:
-                conv['fsl_magnet'] = inner
+                conv['fsl_rotor'] = inner
                 conv['fsl_stator'] = outer
 
             conv['fsl'] = fslrenderer.render_main(
-                machine,
                 machine_inner, machine_outer,
                 inner, outer,
                 params)
@@ -791,7 +791,8 @@ def convert(dxfile,
                 logger.warning("it's not possible to create fsl-file")
                 return None
 
-            fslrenderer = FslRenderer(basename)
+            mtype = 'EESM' if EESM else 'PMSM'
+            fslrenderer = FslRenderer(basename, mtype)
             conv['fsl'] = fslrenderer.render(machine, inner, outer)
 
     if params is not None:
@@ -815,13 +816,18 @@ 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()
     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)
@@ -829,6 +835,7 @@ def create_femag_parameters(m_inner, m_outer, nodedist=1):
         alfa_pole = geom_inner.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
@@ -866,6 +873,7 @@ def create_femag_parameters_stator(motor, position):
     else:
         params['dy1'] = 2*motor.geom.max_radius
         params['da1'] = 2*motor.geom.min_radius
+    params['slot_area'] = motor.slot_area()
     return params
 
 
@@ -879,4 +887,5 @@ def create_femag_parameters_rotor(motor, position):
     else:
         params['dy1'] = 2*motor.geom.max_radius
         params['da1'] = 2*motor.geom.min_radius
+    params['slot_area'] = motor.slot_area()
     return params

femagtools/dxfsl/fslrenderer.py

@@ -9,6 +9,7 @@
 """
 import numpy as np
 from .shape import Shape
+from .area import TYPE_TOOTH, TYPE_YOKE
 import logging
 from .. import __version__
 logger = logging.getLogger(__name__)
@@ -52,12 +53,13 @@ def agndst(da1, da2, Q, p, nodedist=1):
 class FslRenderer(object):
     """a model that can created by FSL"""
 
-    def __init__(self, name):
+    def __init__(self, name, mtype):
         self.model = name
         self.mirror_axis = None
         self.fm_nlin = None
         self.shaft = None
         self.agndst = 1
+        self.mtype = mtype
 
     def mirror_nodechains(self, p0, p1):
         self.mirror_axis = np.array((p0, p1)).ravel().tolist()
@@ -91,7 +93,7 @@ class FslRenderer(object):
         p2 = (center[0] + radius*np.cos(endangle),
               center[1] + radius*np.sin(endangle))
         self.content.append(
-            u"nc_circle_m({}, {}, {}, {}, {}, {}, {})".format(
+            "nc_circle_m({}, {}, {}, {}, {}, {}, {})".format(
                 p1[0], p1[1], p2[0], p2[1],
                 center[0], center[1], num))
 
@@ -118,7 +120,7 @@ class FslRenderer(object):
         n0 = nodes[0]
         for n1 in nodes[1:]:
             self.content.append(
-                u"nc_line({}, {}, {}, {}, {}) -- ellipse".format(
+                "nc_line({}, {}, {}, {}, {}) -- ellipse".format(
                     n0[0], n0[1], n1[0], n1[1], 0))
             n0 = n1
 
@@ -134,12 +136,12 @@ class FslRenderer(object):
                 return
             if e.has_attribute('auxline'):
                 self.content.append(
-                    u"nc_line({}, {}, {}, {}, {}) -- auxiliary".format(
+                    "nc_line({}, {}, {}, {}, {}) -- auxiliary".format(
                         p1[0], p1[1], p2[0], p2[1], num))
                 return
 
         self.content.append(
-            u"nc_line({}, {}, {}, {}, {})".format(
+            "nc_line({}, {}, {}, {}, {})".format(
                 p1[0], p1[1], p2[0], p2[1], num))
 
     def sorted_elements(self, geom, inner=False):
@@ -156,10 +158,21 @@ class FslRenderer(object):
         '''create fsl statements with nodechains'''
         machine.set_alfa_and_corners()
         geom = machine.geom
-        geom.split_lines_longer_than(geom.max_radius/4)
+        split_len = (geom.max_radius - geom.min_radius) / 4
+        geom.split_all_lines_longer_than(split_len)
         self.content = []
 
-        ndt_list = [(0.2, 1.5), (0.45, 2), (0.7, 3.0), (1.1, 3.0)]
+        ndt_list = [(0.00, 1.1),
+                    (0.05, 1.5),
+                    (0.10, 1.7),
+                    (0.15, 2.0),
+                    (0.20, 2.3),
+                    (0.30, 2.7),
+                    (0.40, 3.1),
+                    (0.50, 3.5),
+                    (0.70, 4.5),
+                    (0.85, 5.5),
+                    (1.10, 5.5)]
         dist = geom.max_radius - geom.min_radius
         el_sorted = self.sorted_elements(geom, inner)
 
@@ -184,6 +197,15 @@ class FslRenderer(object):
                     '-- num_slots  = {}'.format(
                         machine.get_num_slots())
                 ]
+                # fix stator subregions
+                sregs = [a.type for a in geom.list_of_areas()
+                         if a.type in (TYPE_YOKE, TYPE_TOOTH)]
+                if len(sregs) > 0 and set(sregs) == {TYPE_TOOTH}:
+                    for a in geom.list_of_areas():
+                        if a.type == TYPE_TOOTH:
+                            a.type = TYPE_YOKE
+                            logger.debug("FIXED STATOR SUBREGION")
+
         self.content += ['-- min_radius = {}'.format(geom.min_radius),
                          '-- max_radius = {}'.format(geom.max_radius),
                          '-- min_corner = {}, {}'.format(
@@ -224,14 +246,16 @@ class FslRenderer(object):
                 'outer_da_end = {}'.format(
                     geom.dist_end_min_corner())
             ]
-
-        self.content += ['\n',
+        if self.mtype == 'PMSM':
+            self.content += [
                          'xmag = {}',
                          'ymag = {}',
-                         'mag_orient = {}',
+                         'mag_orient = {}']
+        self.content += ['\n',
                          'mag_exists = 0',
                          'if mcvkey_yoke == nil then',
                          '  mcvkey_yoke = "dummy"',
+                         '  ur = 1000.0',
                          'end',
                          'x0_iron_tooth, y0_iron_tooth = 0.0, 0.0',
                          'x0_iron_yoke, y0_iron_yoke = 0.0, 0.0',
@@ -242,23 +266,27 @@ class FslRenderer(object):
         num_windings = 0
         num_magnets = 0
         magor = []
+
         for area in geom.list_of_areas():
             if area.number_of_elements() > 1:
                 p = area.get_point_inside(geom)
                 if p:
-                    self.content.append(u"x0, y0 = {}, {}".format(p[0], p[1]))
-                    # self.content.append(u"point(x0, y0, red, 4)")  # for debugging
-                    self.content.append(u"create_mesh_se(x0, y0)")
+                    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)")
 
                 if area.is_winding():
                     if area.type not in subregions:
                         subregions[area.type] = 1
-                    num_windings += 1
-                    rmin, rmax = area.minmax_dist_from_center((0,0))
-                    self.content.append(
-                        f'rcoil_{num_windings} = {rmin}, {rmax}')
-                    self.content.append('m.xcoil_{}, m.ycoil_{} = x0, y0'.
-                                        format(num_windings, num_windings))
+                    if self.mtype == 'PMSM' or outer:
+                        num_windings += 1
+                        rmin, rmax = area.minmax_dist_from_center((0,0))
+                        self.content.append(
+                            f'rcoil_{num_windings} = {rmin}, {rmax}')
+                        self.content.append('m.xcoil_{}, m.ycoil_{} = x0, y0'.
+                                            format(num_windings, num_windings))
+                    else:
+                        self.content.append('m.xcoil_r, m.ycoil_r = x0, y0')
 
                 elif area.is_magnet():
                     if area.type not in subregions:
@@ -296,10 +324,10 @@ class FslRenderer(object):
                         self.content.append(
                             'x0_shaft, y0_shaft = x0, y0')
 
-                self.content.append(u"\n")
+                self.content.append("\n")
 
-        txt = [u"if x0_iron_yoke > 0.0 then",
-               u"  if mcvkey_yoke ~= 'dummy' then",
+        txt = ["if x0_iron_yoke > 0.0 then",
+               "  if mcvkey_yoke ~= 'dummy' then",
                '    def_mat_fm_nlin(x0_iron_yoke, y0_iron_yoke, "blue", mcvkey_yoke, 100)',
                '  else',
                '    def_mat_fm(x0_iron_yoke, y0_iron_yoke, ur, 100)',
@@ -307,21 +335,21 @@ class FslRenderer(object):
                'end\n']
         self.content.append('\n'.join(txt))
 
-        txt = [u"if x0_iron_tooth > 0.0 then",
-               u"  if(x0_iron_yoke == 0 and mcvkey_yoke ~= 'dummy') then",
-               u"    def_mat_fm_nlin(x0_iron_tooth, y0_iron_tooth, 'blue', mcvkey_yoke, 100)",
-               u"  else",
-               u"    if (mcvkey_teeth ~= 'dummy' and mcvkey_teeth ~= nil) then",
-               u"      def_mat_fm_nlin(x0_iron_tooth, y0_iron_tooth, 'blue', mcvkey_teeth, 100)",
-               u"    else",
-               u"      def_mat_fm(x0_iron_tooth, y0_iron_tooth, ur, 100)",
-               u"    end",
-               u"  end",
+        txt = ["if x0_iron_tooth > 0.0 then",
+               "  if(x0_iron_yoke == 0 and mcvkey_yoke ~= 'dummy') then",
+               "    def_mat_fm_nlin(x0_iron_tooth, y0_iron_tooth, 'blue', mcvkey_yoke, 100)",
+               "  else",
+               "    if (mcvkey_teeth ~= 'dummy' and mcvkey_teeth ~= nil) then",
+               "      def_mat_fm_nlin(x0_iron_tooth, y0_iron_tooth, 'blue', mcvkey_teeth, 100)",
+               "    else",
+               "      def_mat_fm(x0_iron_tooth, y0_iron_tooth, ur, 100)",
+               "    end",
+               "  end",
                'end\n']
         self.content.append('\n'.join(txt))
 
-        txt = [u"if x0_shaft > 0.0 then",
-               u"  if mcvkey_shaft ~= 'dummy' then",
+        txt = ['if x0_shaft > 0.0 then',
+               "  if mcvkey_shaft ~= 'dummy' then",
                '    def_mat_fm_nlin(x0_shaft, y0_shaft, "lightgrey", mcvkey_shaft, 100)',
                '  else',
                '    def_mat_fm(x0_shaft, y0_shaft, ur, 100)',
@@ -410,15 +438,15 @@ class FslRenderer(object):
             self.content.append('\nx0, y0 = {}, {}'. format(
                 self.fm_nlin[0], self.fm_nlin[1]))
 
-            mat = [u"if fm_nlin_mcvfile ~= 'dummy' then",
-                   u"  if fm_nlin_mcvfile == 'air' then",
-                   u"    def_mat_fm(x0,y0, 1.0, fm_nlin_rlen)",
-                   u"  else",
-                   u"    def_mat_fm_nlin(x0,y0, fm_nlin_colour, fm_nlin_mcvfile, fm_nlin_rlen)",
-                   u"  end",
-                   u"else",
-                   u"  def_mat_fm(x0,y0, 1000.0, fm_nlin_rlen)",
-                   u"end"]
+            mat = ["if fm_nlin_mcvfile ~= 'dummy' then",
+                   "  if fm_nlin_mcvfile == 'air' then",
+                   "    def_mat_fm(x0,y0, 1.0, fm_nlin_rlen)",
+                   "  else",
+                   "    def_mat_fm_nlin(x0,y0, fm_nlin_colour, fm_nlin_mcvfile, fm_nlin_rlen)",
+                   "  end",
+                   "else",
+                   "  def_mat_fm(x0,y0, 1000.0, fm_nlin_rlen)",
+                   "end"]
             self.content.append('\n'.join(mat))
 
         if self.shaft:
@@ -494,7 +522,6 @@ class FslRenderer(object):
         return self.content
 
     def render_main(self,
-                    motor,
                     m_inner, m_outer,
                     inner, outer,
                     params):
@@ -514,6 +541,27 @@ class FslRenderer(object):
                          m_outer.num_of_layers(),
                          2)
         self.agndst = params.get('agndst', 0.1)
+        excwin = []
+        if self.mtype == 'EESM':
+            excwin = [
+                'r,beta  = c2pr(m.xcoil_r, m.ycoil_r)',
+                'phi = math.pi/m.num_poles',
+                'alpha = phi-beta',
+                'm.num_wires = 1',
+                'dir = {"wi", "wo"}',
+                'xcoil, ycoil = pr2c(r, phi - alpha)',
+                'def_new_wdg(xcoil, ycoil, "violet", "Exc", m.num_wires, 10.0, dir[1])',
+                'xcoil, ycoil = pr2c(r, phi + alpha)',
+                'add_to_wdg(xcoil, ycoil, wsamekey, dir[2], "wser")',
+                'for i = 2, m.npols_gen do',
+                '  n = (i+1) % 2 + 1',
+                '  phi = phi + 2*math.pi/m.num_poles',
+                '  xcoil, ycoil = pr2c(r, phi - alpha)',
+                '  add_to_wdg(xcoil, ycoil, wsamekey, dir[n], "wser")',
+                '  xcoil, ycoil = pr2c(r, phi + alpha)',
+                '  n = i % 2 + 1',
+                '  add_to_wdg(xcoil, ycoil, wsamekey, dir[n], "wser")',
+                'end']
         return [
             '-- generated from DXF by femagtools {}'.format(__version__),
             'exit_on_error = false',
@@ -601,4 +649,4 @@ class FslRenderer(object):
                     '  pre_models("Gen_winding")',
                     '  pre_models("gen_pocfile")',
                     'end\n',
-                    'save_model(cont)\n']
+                    'save_model(cont)\n'] + excwin

femagtools/dxfsl/functions.py

@@ -435,6 +435,14 @@ def points_on_arc(center, radius, startangle, endangle, parts=8):
                center[1] + radius * np.sin(alpha))
 
 
+def points_on_line(p1, p2, parts=2):
+    x_dist = (p2[0] - p1[0]) / parts
+    y_dist = (p2[1] - p1[1]) / parts
+    x, y = p1
+    for i in range(1, parts):
+        yield (x + i*x_dist, y + i*y_dist)
+
+
 class Timer(object):
     def __init__(self, start_it=False):
         self.starttime = None

femagtools/dxfsl/geom.py

@@ -34,7 +34,7 @@ from .functions import middle_point_of_line, middle_point_of_arc
 from .functions import middle_angle, positive_angle
 from .functions import normalise_angle, is_same_angle
 from .functions import part_of_circle, gcd
-from .functions import point_on_arc, nodes_are_equal
+from .functions import point_on_arc, points_on_line, nodes_are_equal
 from .functions import area_size
 import io
 import time
@@ -749,6 +749,38 @@ class Geometry(object):
                              rtol=self.rtol,
                              atol=self.atol)
 
+    def split_all_lines_longer_than(self, length):
+        """split lines longer than length"""
+        new_lines = []
+        rem_lines = []
+        elist = self.elements_and_nodes(Line)
+
+        for p1, p2, line in elist:
+            line_len = line.length()
+            if line_len < length:
+                continue
+            d = abs(distance(self.center, p1) - distance(self.center, p2))
+            parts = 3
+            if d > line_len / 2:
+                parts = 5
+            elif d > line_len / 3:
+                parts = 4
+            p_start = p1
+
+            for p_next in points_on_line(p1, p2, parts=parts):
+                new_lines.append(Line(Element(start=p_start, end=p_next)))
+                p_start = p_next
+
+            new_lines.append(Line(Element(start=p_start, end=p2)))
+            rem_lines.append((p1, p2))
+
+        for p1, p2 in rem_lines:
+            self._remove_edge(p1, p2)
+        for new_line in new_lines:
+            self.add_element(new_line,
+                             rtol=self.rtol,
+                             atol=self.atol)
+
     def circles(self):
         """return list of circle nodes"""
         return [n[1]['object'] for n in self.g.nodes(data=True)
@@ -3574,6 +3606,10 @@ class Geometry(object):
         return len([area for area in self.list_of_areas()
                     if area.is_type(type)])
 
+    def area_size_of_type(self, type):
+        return sum([area.surface for area in self.list_of_areas()
+                    if area.is_type(type)])*1e-3
+
     def num_of_windings(self):
         return self.num_areas_of_type(AREA.TYPE_WINDINGS)
 

femagtools/dxfsl/machine.py

@@ -590,6 +590,10 @@ class Machine(object):
             return w*2
         return w
 
+    def slot_area(self):
+        from .area import TYPE_WINDINGS
+        return self.geom.area_size_of_type(TYPE_WINDINGS)
+
     def find_symmetry(self, sym_tolerance, is_inner, is_outer, plt):
         logger.debug("begin of find_symmetry")
         if self.radius <= 0.0:

femagtools/femag.py

@@ -366,9 +366,9 @@ class BaseFemag(object):
         with open(os.path.join(self.workdir, 'FEMAG-FSL.log')) as f:
             for l in f:
                 if l.startswith('New model') or l.startswith('Load model'):
-                    model = l.split('"')[1]
-                    break
-        return model
+                    return l.split('"')[1]
+
+        raise ValueError(f"Model not found in {self.workdir}/'FEMAG-FSL.log'")
 
     def readResult(self, simulation, bch=None):
         if simulation: