femagtools 1.7.5__py3-none-any.whl → 1.7.7__py3-none-any.whl

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,20 +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
-                    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:
@@ -293,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)',
@@ -304,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)',
@@ -407,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:
@@ -491,7 +522,6 @@ class FslRenderer(object):
         return self.content
 
     def render_main(self,
-                    motor,
                     m_inner, m_outer,
                     inner, outer,
                     params):
@@ -511,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',
@@ -598,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)
@@ -3040,11 +3072,20 @@ class Geometry(object):
                     for e in elist:
                         e.init_attributes('lightblue', 'no_fsl')
 
-    def search_subregions(self, startangle, endangle, single=False):
+    def search_subregions(self, startangle, endangle, EESM, single=False):
         if self.is_stator():
-            self.search_stator_subregions(startangle, endangle, single=single)
+            self.search_stator_subregions(startangle,
+                                          endangle,
+                                          single=single)
         elif self.is_rotor():
-            self.search_rotor_subregions(startangle, endangle, single=single)
+            if EESM:
+                self.search_EESM_rotor_subregions(startangle,
+                                                  endangle,
+                                                  single=single)
+            else:
+                self.search_PMSM_rotor_subregions(startangle,
+                                                  endangle,
+                                                  single=single)
         else:
             logger.warning("no stator or rotor assigned")
             self.search_unknown_subregions()
@@ -3262,25 +3303,88 @@ class Geometry(object):
             self.check_shaft_area(shaft_areas[0])
         logger.debug("End of search_stator_subregions")
 
-    def search_rotor_subregions(self,
-                                startangle,
-                                endangle,
-                                single=False):
-        logger.debug("Begin of search_rotor_subregions")
+    def search_EESM_rotor_subregions(self,
+                                     startangle,
+                                     endangle,
+                                     single=False):
+        logger.debug("Begin of search_EESM_rotor_subregions")
+
+        if self.alfa == 0.0:
+            self.alfa = np.pi * 2.0
+
+        types = {}
+        for area in self.list_of_areas():
+            t = area.mark_EESM_rotor_subregions(self.is_inner,
+                                                self.is_mirrored(),
+                                                self.alfa,
+                                                self.center,
+                                                self.min_radius,
+                                                self.max_radius,
+                                                startangle,
+                                                endangle)
+            if t in types:
+                types[t] += 1
+            else:
+                types[t] = 1
+
+        windings = [a for a in self.list_of_areas()
+                    if a.is_type(AREA.TYPE_WINDINGS_OR_IRON)]
+
+        if self.is_mirrored():
+            [a.set_type(AREA.TYPE_IRON) for a in windings
+             if a.close_to_endangle]
+            wlist = [(a.max_angle, a) for a in self.list_of_areas()
+                     if a.is_type(AREA.TYPE_WINDINGS_OR_IRON)]
+            if wlist:
+                wlist.sort(reverse=True)
+                a, w = wlist[0]
+                w.set_type(AREA.TYPE_FD_WINDINGS)
+        else:
+            midangle = middle_angle(startangle, endangle)
+            [a.set_type(AREA.TYPE_IRON) for a in windings
+             if a.max_angle > midangle and a.min_angle < midangle]
+            windings = [a for a in self.list_of_areas()
+                        if a.is_type(AREA.TYPE_WINDINGS_OR_IRON)]
+            if len(windings) > 1:
+                wlist = []
+                for w in windings:
+                    if w.max_angle < midangle:
+                        angle = alpha_angle(w.max_angle, midangle)
+                    else:
+                        angle = alpha_angle(midangle, w.min_angle)
+                    wlist.append((angle, w))
+                wlist.sort()
+                a1, w1 = wlist[0]
+                a2, w2 = wlist[1]
+                if np.isclose(a1, a2):
+                    w1.set_type(AREA.TYPE_FD_WINDINGS)
+                    w2.set_type(AREA.TYPE_FD_WINDINGS)
+
+        # all remaining areas are in iron
+        [a.set_type(AREA.TYPE_IRON) for a in self.list_of_areas()
+         if a.is_type(AREA.TYPE_WINDINGS_OR_IRON)]
+
+        logger.debug("End of search_EESM_rotor_subregions")
+
+    def search_PMSM_rotor_subregions(self,
+                                     startangle,
+                                     endangle,
+                                     single=False):
+        logger.debug("Begin of search_PMSM_rotor_subregions")
 
         if self.alfa == 0.0:
             self.alfa = np.pi * 2.0
 
         types = {}
         for area in self.list_of_areas():
-            t = area.mark_rotor_subregions(self.is_inner,
-                                           self.is_mirrored(),
-                                           self.alfa,
-                                           self.center,
-                                           self.min_radius,
-                                           self.max_radius,
-                                           startangle,
-                                           endangle)
+            t = area.mark_PMSM_rotor_subregions(self.is_inner,
+                                                self.is_mirrored(),
+                                                self.alfa,
+                                                self.center,
+                                                self.min_radius,
+                                                self.max_radius,
+                                                startangle,
+                                                endangle)
             if t in types:
                 types[t] += 1
             else:
@@ -3408,7 +3512,7 @@ class Geometry(object):
                 self.search_stator_subregions(startangle, endangle, single=single)
             return
 
-        logger.debug("end of search_rotor_subregions")
+        logger.debug("end of search_PMSM_rotor_subregions")
 
     def recalculate_magnet_orientation(self):
         logger.debug("begin of recalculate_magnet_orientation")
@@ -3502,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:
@@ -1046,21 +1050,36 @@ class Machine(object):
         cp_machine.geom.sym_counterpart = self.get_symmetry_part()
         cp_machine.geom.sym_part = cp_machine.get_symmetry_part()
 
-    def search_subregions(self, single=False):
+    def search_subregions(self, EESM, single=False):
         logger.debug("Search subregions")
-        self.geom.search_subregions(self.startangle, self.endangle, single=single)
-
-    def search_rotor_subregions(self, single=False):
-        self.geom.search_rotor_subregions(self.startangle, self.endangle, single=single)
+        self.geom.search_subregions(self.startangle,
+                                    self.endangle,
+                                    EESM,
+                                    single=single)
+
+    def search_rotor_subregions(self, EESM, single=False):
+        if EESM:
+            self.geom.search_EESM_rotor_subregions(self.startangle,
+                                                   self.endangle,
+                                                   single=single)
+        else:
+            self.geom.search_PMSM_rotor_subregions(self.startangle,
+                                                   self.endangle,
+                                                   single=single)
 
     def search_stator_subregions(self, single=False):
-        self.geom.search_stator_subregions(self.startangle, self.endangle, single=single)
+        self.geom.search_stator_subregions(self.startangle,
+                                           self.endangle,
+                                           single=single)
 
-    def rebuild_subregions(self, single=False):
+    def rebuild_subregions(self, EESM, single=False):
         logger.debug("Rebuild subregions")
         self.geom.set_edge_attributes()
         self.geom.area_list = []
-        self.geom.search_subregions(self.startangle, self.endangle, single=single)
+        self.geom.search_subregions(self.startangle,
+                                    self.endangle,
+                                    EESM,
+                                    single=single)
 
     def has_windings(self):
         return self.geom.has_windings
@@ -1170,7 +1189,9 @@ class Machine(object):
             self.geom.area_list = []
             logger.debug("create subregions again")
             self.geom.create_list_of_areas()
-            self.geom.search_subregions(self.startangle, self.endangle)
+            self.geom.search_subregions(self.startangle,
+                                        self.endangle,
+                                        False)
 
         logger.debug("end create_mirror_lines_outside_windings")
 

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: