femagtools 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

femagtools/__init__.py

@@ -9,7 +9,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.3.1'
+__version__ = '1.3.2'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2016-2022 SEMAFOR Informatik & Energie AG'

femagtools/airgap.py

@@ -9,6 +9,7 @@
 """
 import numpy as np
 import logging
+from . import utils
 
 logger = logging.getLogger(__name__)
 
@@ -22,49 +23,22 @@ def fft(pos, b, pmod=0):
       b: (list of floats) flux density values
       pmod: number of poles in model (ignored if 0)
     """
-    model_angle = pos[-1] - pos[0]
-    ntiles = int(round(360/model_angle))
-
-    if pmod:
-        negative_periodic = pmod % 2
-    else:
-        negative_periodic = np.abs(b[0] - b[-1])/np.max(b) > 1
-
-    if negative_periodic:
-        bx = np.append(
-            np.concatenate(
-                [n*b[:-1]
-                 for n in [m % 2 or -1
-                           for m in range(1, ntiles+1)]]),
-            b[0])
-    else:
-        bx = np.append(
-            np.tile(b[:-1], ntiles),
-            b[0])
-
-    N = len(bx)
-    # compute DFT from induction
-    Y = np.fft.fft(bx)
-
-    # find the peak (amplitude of base harmonic)
-    i = np.argmax(np.abs(Y[:N//2]))
-    a = 2*np.abs(Y[i])/N
-    freq = np.fft.fftfreq(N, d=pos[1]-pos[0])
-    T0 = np.abs(1/freq[i])
+    r = utils.fft(pos, b, pmod)
+    Bamp = r['a']
+    alfa0 = r['alfa0']
+    T0 = r['T0']
     npoles = 2*int(np.ceil(360/T0))
     logger.info("flux density: %s poles B amp %f ",
-                npoles, a)
-
-    alfa0 = np.angle(Y[i])
-    return dict(Bamp=a, npoles=npoles,
+                npoles, r['a'])
+    return dict(Bamp=Bamp, npoles=npoles,
                 phi0=alfa0,
                 pos=pos.tolist(),
                 B=b.tolist(),
                 nue=np.arange(0, 9*npoles).tolist(),
-                B_nue=(2*np.abs(Y[:9*npoles])/N).tolist(),
-                B_fft=(a*np.cos(2*np.pi*pos/T0+alfa0)).tolist(),
-                Bi=bx.tolist(),
-                phi=np.linspace(pos[0], 360+pos[0], len(bx)).tolist())
+                B_nue=r['nue'],
+                B_fft=(Bamp*np.cos(2*np.pi*pos/T0+alfa0)).tolist(),
+                Bi=r['yi'],
+                phi=np.linspace(pos[0], 360+pos[0], len(r['yi'])).tolist())
 
 
 def read(filename, pmod=0):

femagtools/amela.py

@@ -314,7 +314,8 @@ class Amela():
                                 bndy=[float(c) for c in bndy[i]],
                                 bl=bl[i],
                                 elcp=elcp[i],
-                                area=spel_area[i]))
+                                area=spel_area[i], 
+                                spel_key=spel_key[i]))
             pm_data[i].update(pos)
 
         for k in range(len(pm_node_key)):

femagtools/bch.py

@@ -170,6 +170,7 @@ class Reader:
         self.dqPar = {}
         self.ldq = {}
         self.losses = []
+        self.magnet_loss_th = []
         self.demag = []
         self.weights = []
         self.weight = {}
@@ -1497,11 +1498,12 @@ class Reader:
             if l.find('Fe-Losses-Rotor') > -1:
                 rec = self.__findNums(content[i+3])
                 if len(rec) == 2:
-                    if content[i+1].find('Iron') > -1 and content[i+1].find('StJo') > 0:
+                    if (content[i+1].find('Iron') > -1 and content[i+1].find('StJo') > 0 or
+                        content[i+1].split() == ['RoZa', 'RoJo']):
                         self.external_rotor = True
                         # TODO: there might be better places to check this
-                        losses['stajo'] = floatnan(rec[0])
-                        losses['staza'] = floatnan(rec[1])
+                        losses['staza'] = floatnan(rec[0])
+                        losses['stajo'] = floatnan(rec[1])
                         losses['total'] += losses['staza']+losses['stajo']
                     else:
                         losses['rotfe'] = floatnan(rec[1])
@@ -1509,6 +1511,20 @@ class Reader:
                 i += 4
                 continue
 
+            if l.find('Fe-Losses-Stator') > -1:
+                rec = self.__findNums(content[i+3])
+                if len(rec) == 2:
+                    if content[i+1].split() == ['StJo', 'StZa']:
+                        losses['stajo'] = floatnan(rec[0])
+                        losses['staza'] = floatnan(rec[1])
+                        losses['total'] += losses['staza']+losses['stajo']
+
+                    if content[i+1].split() == ['rotf', '----']:
+                        losses['rotfe'] = sum([floatnan(x) for x in rec])
+                        losses['total'] += losses['rotfe']
+                i += 4
+                continue
+
             if l.find('Magnet-Losses') > -1:
                 rec = self.__findNums(content[i+1])
                 if len(rec) == 1:

femagtools/dxfsl/area.py

@@ -39,6 +39,8 @@ class Area(object):
         self.min_air_angle = 0.0
         self.max_air_angle = 0.0
         self.close_to_ag = False
+        self.close_to_ag_startcorner = False
+        self.close_to_ag_endcorner = False
         self.close_to_startangle = False
         self.close_to_endangle = False
         self.mag_rectangle = False
@@ -1056,6 +1058,12 @@ class Area(object):
                         return True
         return False
 
+    def is_touching_areas(self, areas):
+        for a in areas:
+            if self.is_touching(a):
+                return True
+        return False
+
     def mark_stator_subregions(self,
                                is_inner,
                                stator_size,
@@ -1155,18 +1163,37 @@ class Area(object):
                 logger.debug("***** air (part of a circle)\n")
                 return self.type
 
+        def bad_winding_position():
+            if is_inner:
+                radius_third = airgap_radius - (airgap_radius - opposite_radius) * 0.33
+                if self.max_dist < radius_third:
+                    return True
+            else:  # outer
+                radius_third = airgap_radius + (opposite_radius - airgap_radius) * 0.33
+                if self.min_dist > radius_third:
+                    return True
+            return False
+
         if self.min_angle > 0.001:
             if self.max_angle < alpha - 0.001:
-                self.type = 2  # windings
-                logger.debug("***** windings #1\n")
+                if bad_winding_position():
+                    self.type = 12  # windings or air
+                    logger.debug("***** windings or air #1\n")
+                else:
+                    self.type = 2  # windings
+                    logger.debug("***** windings #1\n")
                 return self.type
             if mirrored:
-                self.type = 2  # windings
-                logger.debug("***** windings #2\n")
+                if bad_winding_position():
+                    self.type = 12  # windings or air
+                    logger.debug("***** windings or air #2\n")
+                else:
+                    self.type = 2  # windings
+                    logger.debug("***** windings #2\n")
                 return self.type
 
             self.type = 0  # air
-            logger.debug("***** air #2")
+            logger.debug("***** air #3")
 
         if self.close_to_startangle or self.close_to_endangle:
             f = self.surface / stator_size
@@ -1179,7 +1206,7 @@ class Area(object):
                 logger.debug("***** air or iron close to border\n")
             return self.type
 
-        logger.debug("***** air #3\n")
+        logger.debug("***** air #4\n")
         return 0
 
     def mark_rotor_subregions(self, is_inner, mirrored, alpha,
@@ -1331,6 +1358,15 @@ class Area(object):
         logger.debug(">>> air remains")
         return self.type
 
+    def mark_airgap_corners(self, start_cp, end_cp):
+        for n in self.list_of_nodes():
+            if self.close_to_startangle:
+                if points_are_close(n, start_cp):
+                    self.close_to_ag_startcorner = True
+            if self.close_to_endangle:
+                if points_are_close(n, end_cp):
+                    self.close_to_ag_endcorner = True
+
     def area_size(self):
         nodes = [n for n in self.list_of_nodes()]
         return area_size(nodes)
@@ -1467,14 +1503,19 @@ class Area(object):
 
     def __str__(self):
         return "Area {}\n".format(self.id) + \
-            "distance: from {} to {}\n".\
+            "distance...............: from {} to {}\n".\
             format(round(self.min_dist, 4), round(self.max_dist, 4)) + \
-            "height..: {}\n".format(self.height) + \
-            "alpha...: {}\n".format(self.alpha) + \
-            "angle...: from {} to {}\n".\
+            "height.................: {}\n".format(self.height) + \
+            "alpha..................: {}\n".format(self.alpha) + \
+            "angle..................: from {} to {}\n".\
             format(round(self.min_angle, 6), round(self.max_angle, 6)) + \
-            "delta...: {}\n".format(self.delta) + \
-            "number..: {}\n".format(self.count) + \
-            "equal...: {}\n".format(len(self.equal_areas)) + \
-            "symmetry: {}\n".format(self.symmetry) + \
-            "sym_type: {}".format(self.sym_type)
+            "delta..................: {}\n".format(self.delta) + \
+            "number.................: {}\n".format(self.count) + \
+            "equal areas............: {}\n".format(len(self.equal_areas)) + \
+            "symmetry...............: {}\n".format(self.symmetry) + \
+            "symmetry type..........: {}\n".format(self.sym_type) + \
+            "close to airgap........: {}\n".format(self.close_to_ag) + \
+            "close to startangle....: {}\n".format(self.close_to_startangle) + \
+            "close to endangle......: {}\n".format(self.close_to_endangle) + \
+            "close to ag startcorner: {}\n".format(self.close_to_ag_startcorner) + \
+            "close to ag endcorner..: {}\n".format(self.close_to_ag_endcorner)

femagtools/dxfsl/converter.py

@@ -399,6 +399,7 @@ def convert(dxfile,
                     machine = machine.undo_mirror()
                     machine.geom.set_stator()
                     machine.geom.search_stator_subregions(part[1])
+                    machine.geom.looking_for_corners()
                     machine.create_mirror_lines_outside_windings()
 
                 params = create_femag_parameters_stator(machine,
@@ -406,6 +407,7 @@ def convert(dxfile,
             else:
                 machine.geom.set_rotor()
                 machine.geom.search_rotor_subregions(part[1])
+                machine.geom.looking_for_corners()
                 params = create_femag_parameters_rotor(machine,
                                                        part[1])
         else:

femagtools/dxfsl/geom.py

@@ -276,6 +276,32 @@ def lw_polyline(entity, lf, xoff=0.0, yoff=0.0, rotation=0.0):
                    xoff=xoff, yoff=yoff,
                    rotation=rotation)
 
+def ellipse(entity, lf, xoff=0.0, yoff=0.0, rotation=0.0):
+    w = np.linalg.norm(entity.major_axis) * 2
+    h = entity.ratio * w
+    theta = np.arctan2(entity.major_axis[1], entity.major_axis[0])
+    start_angle = entity.start_param
+    end_angle = entity.end_param
+    if end_angle < start_angle:
+        end_angle += 2*np.pi
+    alfa = np.linspace(start_angle, end_angle, 20)
+    x = 0.5 * w * np.cos(alfa)
+    y = 0.5 * h * np.sin(alfa)
+    R = np.array([
+        [np.cos(theta), -np.sin(theta)],
+        [np.sin(theta),  np.cos(theta)]
+    ])
+    x, y = np.dot(R, [x, y])
+    x += entity.center[0]
+    y += entity.center[1]
+    points = np.array((x,y)).T
+    p1 = points[0]
+    for p2 in points[1:]:
+        yield Line(Element(start=p1, end=p2), lf,
+                   xoff=xoff, yoff=yoff,
+                   rotation=rotation)
+        p1 = p2
+
 
 def spline(entity, lf, min_dist=0.001, xoff=0.0, yoff=0.0, rotation=0.0):
     if False:
@@ -493,22 +519,26 @@ def dxfshapes(dxffile, mindist=0.01, layers=[]):
                 for l in insert_block(dwg, e, lf, rf, block, min_dist=mindist):
                     yield l
             elif e.dxftype == 'ELLIPSE':
-                w = np.linalg.norm(e.major_axis) * 2
-                h = e.ratio * w
-                rtheta = np.arctan2(e.major_axis[1], e.major_axis[0])
-                angle = rtheta*180/np.pi
-                start_angle = e.start_param*180/np.pi + angle
-                end_angle = e.end_param*180/np.pi + angle
-                arc = Arc(Element(center=e.center,
-                                  radius=w/2,
-                                  start_angle=start_angle,
-                                  end_angle=end_angle,
-                                  width=w,
-                                  height=h,
-                                  rtheta=rtheta,
-                                  start_param=e.start_param,
-                                  end_param=e.end_param))
-                yield arc
+                for l in ellipse(e, lf):
+                    yield l
+                #w = np.linalg.norm(e.major_axis) * 2
+                #h = e.ratio * w
+                #rtheta = np.arctan2(e.major_axis[1], e.major_axis[0])
+                #angle = rtheta*180/np.pi
+                #start_angle = e.start_param*180/np.pi + angle
+                #end_angle = e.end_param*180/np.pi + angle
+                #if end_angle < start_angle:
+                #    end_angle += 360
+                #arc = Arc(Element(center=e.center,
+                #                  radius=w/2,
+                #                  start_angle=start_angle,
+                #                  end_angle=end_angle,
+                #                  width=w,
+                #                  height=h,
+                #                  rtheta=rtheta,
+                #                  start_param=e.start_param,
+                #                  end_param=e.end_param))
+                #yield arc
 
             elif e.dxftype == 'POINT':
                 logger.debug("Id %d4: type %s ignored", id, e.dxftype)
@@ -994,12 +1024,28 @@ class Geometry(object):
     def add_line(self, n1, n2, color=None):
         line = Line(Element(start=n1, end=n2), color=color)
         add_or_join(self,
-                    line.node1(ndec),
-                    line.node2(ndec),
+                    n1,
+                    n2,
                     line,
                     self.rtol,
                     self.atol)
 
+    def add_arc(self, n1, n2, center, radius, color=None):
+        angle_n1 = alpha_line(center, n1)
+        angle_n2 = alpha_line(center, n2)
+        arc = Arc(Element(center=center,
+                          radius=radius,
+                          start_angle=angle_n1*180/np.pi,
+                          end_angle=angle_n2*180/np.pi),
+                  color=color)
+        add_or_join(self,
+                    n1,
+                    n2,
+                    arc,
+                    self.rtol,
+                    self.atol)
+
+
     def elements(self, type):
         """return lists of objects"""
         return [e[2]['object'] for e in self.g.edges(data=True)
@@ -2631,7 +2677,7 @@ class Geometry(object):
             dist_max = max(dist_max, g[1])
         return airgaps
 
-    def detect_airgaps(self, center, startangle, endangle, atol):
+    def detect_airgaps(self, center, startangle, endangle, atol=0.1, with_end=False):
         """ Die Funktion sucht Luftspalt-Kandidaten und liefert eine Liste
             von Möglichkeiten mit jeweils einem minimalen und einem maximalen
             Radius als Begrenzung des Luftspalts.
@@ -2651,6 +2697,8 @@ class Geometry(object):
         min_radius = self.min_radius + 1.0
         cur_radius = gaplist[0][1]
         max_radius = self.max_radius - 1.0
+        if with_end:
+            max_radius = self.max_radius + 1.0
 
         for g in gaplist:
             if greater(g[0], cur_radius) and \
@@ -3024,13 +3072,31 @@ class Geometry(object):
 
     def search_subregions(self):
         if self.is_stator():
-            return self.search_stator_subregions()
+            self.search_stator_subregions()
+        elif self.is_rotor():
+            self.search_rotor_subregions()
+        else:
+            logger.warning("no stator or rotor assigned")
+            self.search_unknown_subregions()
+        self.looking_for_corners()
 
-        if self.is_rotor():
-            return self.search_rotor_subregions()
+    def collect_windings(self):
+        found = True
+        while found:
+            windings = [a for a in self.list_of_areas()
+                        if a.type == 2]
+            bad_windings = [a for a in self.list_of_areas()
+                            if a.type == 12]
+            if not bad_windings:
+                return windings
+
+            found = False
+            for a in bad_windings:
+                if a.is_touching_areas(windings):
+                    a.type = 2
+                    found = True
 
-        logger.warning("no stator or rotor assigned")
-        return self.search_unknown_subregions()
+        return [a for a in self.list_of_areas() if a.type == 2]
 
     def search_stator_subregions(self, place=''):
         logger.debug("Begin of search_stator_subregions")
@@ -3053,8 +3119,8 @@ class Geometry(object):
                                         self.min_radius,
                                         self.max_radius)
 
-        windings = [a for a in self.list_of_areas()
-                    if a.type == 2]
+        windings = self.collect_windings()
+        [a.set_type(0) for a in self.list_of_areas() if a.type == 12]
         windings_found = len(windings)
         logger.info("%d windings found", windings_found)
 
@@ -3063,7 +3129,7 @@ class Geometry(object):
             windings_surface.sort(reverse=True)
             max_size = windings_surface[0][0]
             for sz, w in windings_surface:
-                logger.info("winding size = %s", sz)
+                logger.debug("winding size = %s", sz)
                 if sz / max_size < 0.95:
                     w.set_type(0)
                     if sz / max_size < 0.2:
@@ -3328,7 +3394,21 @@ class Geometry(object):
                     if a.surface < max_surface * 0.20:  # too small
                         a.set_type(0)  # air
 
-        logger.debug("begin of search_unknown_subregions")
+        logger.debug("end of search_unknown_subregions")
+
+    def looking_for_corners(self):
+        if self.is_inner:
+            logger.debug("looking_for_corners: inner")
+            start_cp = self.start_corners[-1]
+            end_cp = self.end_corners[-1]
+        else:
+            logger.debug("looking_for_corners: outer")
+            start_cp = self.start_corners[0]
+            end_cp = self.end_corners[0]
+        logger.debug("looking_for_corners: start=%s, end=%s",
+                     start_cp, end_cp)
+        for area in self.list_of_areas():
+            area.mark_airgap_corners(start_cp, end_cp)
         return
 
     def num_areas_of_type(self, type):
@@ -3581,19 +3661,16 @@ class Geometry(object):
             c += self.remove_appendix(n2, nbrs[0], incr_text + '.')
         return c
 
-    def split_and_get_intersect_points(self, center, outer_radius, angle):
+    def split_and_get_intersect_points(self, el, aktion=True):
         logger.debug("begin of split_and_get_intersect_points")
         rtol = 1e-03
         atol = 1e-03
-        line = Line(
-            Element(start=center,
-                    end=point(center, outer_radius+1, angle)))
         points = []
         for e in self.elements(Shape):
-            pts = e.intersect_line(line,
-                                   rtol=rtol,
-                                   atol=atol,
-                                   include_end=True)
+            pts = e.intersect_shape(el,
+                                    rtol=rtol,
+                                    atol=atol,
+                                    include_end=True)
             if pts:
                 pts_inside = []
                 pts_real = []
@@ -3608,7 +3685,7 @@ class Geometry(object):
                         pts_real.append(p)
                         pts_inside.append(p)
 
-                if pts_inside:
+                if pts_inside and aktion:
                     self.remove_edge(e)
                     elements = e.split(pts_inside, rtol, atol)
                     for e in elements:
@@ -3631,6 +3708,31 @@ class Geometry(object):
                         return True
         return False
 
+    def inside_area_list(self, p):
+        for area in self.list_of_areas():
+            if area.is_point_inside(p):
+                yield area
+
+    def critical_touch_point(self, points):
+        logger.debug("looking for critical touch-point")
+        winding_touched = False
+        for p in points[1:]:
+            d = distance(self.center, p)
+            logger.debug("-- p = %s, dist = %s", p, d)
+            for a in self.inside_area_list(p):
+                logger.debug("-- Area type = %s", a.type)
+                logger.debug("        min=%s,  max= %s", a.min_dist, a.max_dist)
+                logger.debug("        close to start = %s", a.close_to_startangle)
+                logger.debug("        close to end   = %s", a.close_to_endangle)
+                if a.is_winding():
+                    winding_touched = True
+                else:
+                    if winding_touched and greater(a.max_dist, d, atol=0.001):
+                        if not (a.close_to_startangle and a.close_to_endangle):
+                            logger.debug("-- return %s", p)
+                            return p
+        return None
+
     def create_lines_outside_windings(self, points):
         if not points:
             return False
@@ -3661,16 +3763,23 @@ class Geometry(object):
         return False
 
     def get_inner_airgap_line(self):
+        logger.debug("begin of get_inner_airgap_line")
+
         if not self.is_inner:
+            logger.debug("end of get_inner_airgap_line: not inner")
             return []
-        area = [a for a in self.area_list if a.close_to_endangle and a.close_to_ag]
+        for a in self.area_list:
+            logger.debug("%s", a)
+        area = [a for a in self.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 []
 
         end_corner = self.end_corners[-1]
         logger.debug("END CORNER %s", end_corner)
         nodes = [n for n in area[0].list_of_nodes()]
         if not nodes:
+            logger.debug("end of get_inner_airgap_line: no nodes found")
             return []
         n1 = nodes[0]
         if points_are_close(end_corner, n1):
@@ -3683,6 +3792,7 @@ class Geometry(object):
                 n2 = n1
 
         if not points_are_close(end_corner, n1):
+            logger.debug("end of get_inner_airgap_line: not close to endcorner")
             return []
 
         start_corner = self.start_corners[-1]
@@ -3697,6 +3807,7 @@ class Geometry(object):
             n2 = info['n2']
             nodes.append(n2)
 
+        logger.debug("end of get_inner_airgap_line #%s", len(nodes))
         return nodes
 
     def create_corner_areas(self):
@@ -3743,7 +3854,11 @@ class Geometry(object):
                 if not self.search_intersection(i, self.max_radius,
                                                 n, start_cp,
                                                 airgap_nodes):
-                    self.add_line(start_cp, n, color='red')
+                    d = distance(self.center, n)
+                    if np.isclose(d, self.max_radius):
+                        self.add_arc(start_cp, n, self.center, self.max_radius, color='red')
+                    else:
+                        self.add_line(start_cp, n, color='red')
                     self.add_edge(cp, start_cp, start_line)
                     self.create_and_append_area(start_cp, n)
                     self.start_corners = self.get_corner_nodes(self.center,
@@ -3762,7 +3877,11 @@ class Geometry(object):
                 if not self.search_intersection(i, self.max_radius,
                                                 n, end_cp,
                                                 airgap_nodes):
-                    self.add_line(end_cp, n, color='red')
+                    d = distance(self.center, n)
+                    if np.isclose(d, self.max_radius):
+                        self.add_arc(n, end_cp, self.center, self.max_radius, color='red')
+                    else:
+                        self.add_line(end_cp, n, color='red')
                     self.add_edge(cp, end_cp, end_line)
                     self.create_and_append_area(n, end_cp)
                     self.end_corners = self.get_corner_nodes(self.center,
@@ -3788,7 +3907,7 @@ class Geometry(object):
                 logger.debug("end of search_intersection: bad")
                 return True  # fatal
             dist_p = distance(self.center, pts[0])
-            logger.info("-- check point %s[%s] -- %s[%s]", n, dist_n, pts[0], dist_p)
+            logger.debug("-- check point %s[%s] -- %s[%s]", n, dist_n, pts[0], dist_p)
             if not less(dist_n, dist_p):
                 logger.debug("end of search_intersection: found")
                 return True  # intersection