femagtools 1.6.0__py3-none-any.whl → 1.6.2__py3-none-any.whl

femagtools/__init__.py

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

femagtools/bch.py

@@ -269,6 +269,28 @@ class Reader:
             self.weight['conductor'] = sum(w[1])
             self.weight['magnet'] = sum(w[2])
             self.weight['total'] = sum([sum(l) for l in w])
+
+        # check if cogging and fft
+        try:
+            if (self.type.startswith('Fast cogging')
+                and not self.torque_fft):
+                from .utils import fft
+                # calc frequency sepctrum (assume a full period)
+                f = fft(self.torque[0]['angle'],
+                        self.torque[0]['torque'], pmod=2)
+                slots = self.machine['Q']
+                poles = 2*self.machine['p']
+                n = np.lcm(slots, poles)
+                nue = np.arange(0, 5*n).tolist()
+                order, tq = np.array(
+                    [(n, b)
+                     for n, b in zip(nue, f['nue']) if b > 1e-15 and 2*n % poles == 0]).T
+                self.torque_fft = [
+                    {'order': order.tolist(),
+                     'torque': tq.tolist()}]
+        except (KeyError, IndexError):
+            pass
+
         return self
 
     def __findNums(self, l):
@@ -1006,9 +1028,9 @@ class Reader:
         e.g. : idList[-450, -350, -250, -150, -50, 0]
                idList[-500, -400, -300, -200, -100, 0, 0]
         '''
+        diff = np.floor(np.abs(np.diff(idList)))
         if idList[-1] == 0 and len(idList) > 2 and \
-           int(idList[-1] - idList[0]) / (len(idList)-1) != \
-           int(idList[-2] - idList[0]) / (len(idList)-2):
+           not np.all(diff == diff[0]):
             idList = idList[:-1]
         return idList
 
@@ -1172,7 +1194,7 @@ class Reader:
             cols += [s+'_hyst', s+'_eddy']
         if m:
             # FEMAG-2024.2
-            if len(m[0]) > len(subregs[:-1])*2+2: 
+            if len(m[0]) > len(subregs[:-1])*2+2:
                 cols = []
                 for s in subregs[:-2] + ['rotor', 'magnet']:
                     cols += [s+'_hyst', s+'_eddy', s+'_excess']

femagtools/dxfsl/conv.py

@@ -119,9 +119,13 @@ def main():
                            dest='debug',
                            action="store_true")
     argparser.add_argument('-l', '--log',
-                           help='print information in logfile',
+                           help='print information in logfile and set --debug',
                            dest='debug',
                            action="store_true")
+    argparser.add_argument('--logfile',
+                           help='print information in logfile',
+                           dest='logfile',
+                           action="store_true")
     argparser.add_argument('--version',
                            help='show version of some packages',
                            dest='version',
@@ -137,6 +141,7 @@ def main():
     loglevel = logging.INFO
     if args.debug:
         loglevel = logging.DEBUG
+    if args.debug or args.logfile:
         logfilename = 'debugger.log'
         print("see log-messages in {}".format(logfilename))
 

femagtools/dxfsl/functions.py

@@ -11,6 +11,7 @@ from __future__ import print_function
 import logging
 import numpy as np
 import copy
+import time
 
 logger = logging.getLogger('femagtools.functions')
 
@@ -112,9 +113,11 @@ def round_point(p, n):
     return (round(p[0], n), round(p[1], n))
 
 
-def line_m(p1, p2):
+def line_m(p1, p2, none_val=None, dec=0):
     if np.isclose(p2[0]-p1[0], 0.0):
-        return None
+        return none_val
+    if dec > 0:
+        return round((p2[1]-p1[1]) / (p2[0]-p1[0]), dec)
     return (p2[1]-p1[1]) / (p2[0]-p1[0])
 
 
@@ -241,6 +244,14 @@ def points_are_close(p1, p2, rtol=1e-05, atol=1e-08):
             np.isclose(p1[1], p2[1], rtol, atol))
 
 
+def point_greater_equal(p1, p2, rtol=1e-05, atol=1e-08):
+    if not (p1 and p2):
+        return False
+    if np.isclose(p1[0], p2[0], rtol, atol):  # x equal
+        return greater_equal(p1[1], p2[1], rtol, atol)  # y >= equal
+    return greater_equal(p1[0], p2[0], rtol, atol)  # x >= equal
+
+
 def nodes_are_equal(n1, n2):
     if not (n1 and n2):
         return False
@@ -275,6 +286,14 @@ def normalise_angle(alpha):
     return alpha
 
 
+def positive_angle(alpha):
+    """ returns a positive value for angle alpha
+    """
+    while alpha < 0.0:
+        alpha += 2*np.pi
+    return alpha
+
+
 def is_same_angle(angle1, angle2, atol=0.001):
     """ returns true if angles are equal
     """
@@ -404,3 +423,31 @@ def points_on_arc(center, radius, startangle, endangle, parts=8):
     for alpha in angles_on_arc(start, end, parts=parts):
         yield (center[0] + radius * np.cos(alpha),
                center[1] + radius * np.sin(alpha))
+
+
+class Timer(object):
+    def __init__(self, start_it=False):
+        self.starttime = None
+        if start_it:
+            self.start()
+
+    def __str__(self):
+        if self.starttime is None:
+            return "Timer is not running"
+        stop = time.perf_counter()
+        return "Timer is already running for %0.4f seconds" % (stop - self.starttime)
+
+    def start(self):
+        if self.starttime is not None:
+            logger.error("Timer is already on")
+        self.starttime = time.perf_counter()
+
+    def stop(self, fmt=None):
+        if self.starttime is None:
+            logger.error("Timer is not running")
+        stop = time.perf_counter()
+        sec = stop - self.starttime
+        self.starttime = None
+        if fmt:
+            logger.info(fmt, sec)
+        return sec

femagtools/dxfsl/geom.py

@@ -135,49 +135,50 @@ def add_or_join(geom, n1, n2, entity, rtol, atol):
             "Tiny element with same node on both sides ignored: %s", n1)
         logger.debug(
             " -- element: %s", entity)
+        return
 
-    else:
-        e = geom.get_edge_element(n1, n2)
-        if e:
-            logger.debug("Duplicate connection: %s <--> %s", n1, n2)
-            if is_Line(e):
-                if is_Line(entity):
-                    logger.debug("add_or_join(): Duplicate Lines ignored")
+    e = geom.get_edge_element(n1, n2)
+    if not e:  # no duplicates
+        geom.add_edge(n1, n2, entity)
+        return
+
+    logger.debug("Duplicate connection: %s <--> %s", n1, n2)
+    if is_Line(e):
+        if is_Line(entity):
+            logger.debug("add_or_join(): Duplicate Lines ignored")
+            return  # its ok
+
+    if is_Arc(e):
+        if is_Arc(entity):
+            if points_are_close(e.center, entity.center, rtol=rtol, atol=atol):
+                if points_are_close(e.p1, entity.p1):
+                    logger.debug("add_or_join(): Duplicate Arcs ignored")
                     return  # its ok
 
-            if is_Arc(e):
-                if is_Arc(entity):
-                    if points_are_close(e.center, entity.center, rtol=rtol, atol=atol):
-                        if points_are_close(e.p1, entity.p1):
-                            logger.debug("add_or_join(): Duplicate Arcs ignored")
-                            return  # its ok
+    if is_Circle(entity):
+        if is_Circle(e):
+            logger.debug("add_or_join(): Duplicate Circle ignored")
+            return  # its ok
 
-            if is_Circle(entity):
-                if is_Circle(e):
-                    logger.debug("add_or_join(): Duplicate Circle ignored")
-                    return  # its ok
+    if is_Circle(entity) or is_Circle(e):
+        e1, e2 = entity.cut_into_halves()
+        logger.debug("===== add_or_join(): Element near circle is cut into halves =====")
+        add_element(geom, e1, rtol, atol)
+        add_element(geom, e2, rtol, atol)
+        return  # halves installed
 
-            if is_Circle(entity) or is_Circle(e):
-                e1, e2 = entity.cut_into_halves()
-                logger.debug("===== add_or_join(): Element near circle is cut into halves =====")
-                add_element(geom, e1, rtol, atol)
-                add_element(geom, e2, rtol, atol)
-                return  # halves installed
-
-            m1 = e.center_of_connection()
-            m2 = entity.center_of_connection()
-            logger.debug("midpoints: %s -- %s", m1, m2)
-            if points_are_close(m1, m2, rtol, 1e-2):
-                logger.debug("Elements are close together")
-                return  # ok
-
-            e1, e2 = entity.cut_into_halves()
-            logger.debug("===== add_or_join(): cut into halves =====")
-            add_element(geom, e1, rtol, atol)
-            add_element(geom, e2, rtol, atol)
-            return  # halves installed
+    m1 = e.center_of_connection()
+    m2 = entity.center_of_connection()
+    logger.debug("midpoints: %s -- %s", m1, m2)
+    if points_are_close(m1, m2, rtol, 1e-2):
+        logger.debug("Elements are close together")
+        return  # ok
 
-        geom.add_edge(n1, n2, entity)
+    e1, e2 = entity.cut_into_halves()
+    logger.debug("===== add_or_join(): cut into halves =====")
+    add_element(geom, e1, rtol, atol)
+    add_element(geom, e2, rtol, atol)
+    return  # halves installed
 
 
 def get_nodes_of_paths(g, c):
@@ -1108,12 +1109,13 @@ class Geometry(object):
         # Linie als Corner-Objekte.
         corners = [Corner(center, c)
                    for c in self.angle_nodes(center, angle, rtol, atol)]
+        center_added = len(corners) == 1
         if len(corners) == 1:
             logger.debug('get_corner_list: the center is a corner')
             corners.append(Corner(center, tuple(center)))
         if len(corners) > 1:
             corners.sort()
-        return corners
+        return center_added, corners
 
     def start_min_corner(self, i):
         return self.start_corners[0][i]
@@ -1204,11 +1206,13 @@ class Geometry(object):
         end_pts = [p for p in reversed(self.end_corners)]
         return area_size(pts + end_pts)
 
-    def repair_hull_line(self, center, angle, corners, with_center):
+    def repair_hull_line(self, center, angle, corners, with_center, rtol=None, atol=None):
         # We need to set our own tolerance range
         # to find the right points
-        rtol = 1e-4
-        atol = 1e-4
+        if not rtol:
+            rtol = 1e-3
+        if not atol:
+            atol = 1e-3
 
         logger.debug("begin repair_hull_line(center=%s, angle=%s)", center, angle)
 
@@ -1270,7 +1274,7 @@ class Geometry(object):
             logger.warn("Warning: %s", e)
 
         # Rebuild Corner-list after correction
-        corners = self.get_corner_list(center, angle, rtol, atol)
+        center_added, corners = self.get_corner_list(center, angle, rtol, atol)
         for c in corners:
             logger.debug("Correct Corner: %s", c)
 
@@ -1309,7 +1313,7 @@ class Geometry(object):
         if not self.center:
             raise ValueError("FATAL ERROR: no center in Geometry")
 
-        corners = self.get_corner_list(self.center, angle)
+        center_added, corners = self.get_corner_list(self.center, angle)
         assert(corners)
         c_min = Corner(self.center, point(self.center, self.min_radius, angle, ndec))
         c_max = Corner(self.center, point(self.center, self.max_radius, angle, ndec))
@@ -1362,7 +1366,7 @@ class Geometry(object):
         rtol = 1e-4
         atol = 1e-4
 
-        corners = self.get_corner_list(center, angle, rtol, atol)
+        center_added, corners = self.get_corner_list(center, angle, rtol, atol)
         if len(corners) < 2:
             return ()  # not enough corners
         return (corners[0].point(), corners[len(corners)-1].point())
@@ -1903,6 +1907,9 @@ class Geometry(object):
                                         radius=e.radius,
                                         start_angle=alpha_start*180/np.pi,
                                         end_angle=alpha_end*180/np.pi))
+                    if points_are_close(a.p1, a.p2, rtol=1e-02, atol=1e-02):
+                        logger.debug("ATTENTION: creation of a tiny arc")
+                        a.set_attribute("tiny")
                     new_elements.append(a)
             alpha_start = alpha_end
             p1 = p2
@@ -1998,7 +2005,8 @@ class Geometry(object):
                    atol=0.0,
                    append_inner=False,
                    append_outer=False,
-                   delete_appendices=False):
+                   delete_appendices=False,
+                   concatenate_tiny_el=False):
         """ Die Funktion kopiert die Teile von Shape-Objekten, welche sich in
             der durch die Parameter definierten Teilkreisfläche befinden.
         """
@@ -2099,6 +2107,11 @@ class Geometry(object):
                 new_elements.append(arc)
                 p1 = p2
 
+        if concatenate_tiny_el:
+            ok, new_elements = self.concatenate_tiny_elements(new_elements)
+            if ok:
+                split = True
+
         if delete_appendices:
             center = []
         else:
@@ -2183,6 +2196,78 @@ class Geometry(object):
                 return False
         return True
 
+    def concatenate_arc_elements(self, el, elements):
+        if not is_Arc(el):
+            return False
+
+        def match(e1, e2):
+            if e2.has_attribute("del"):
+                return False
+            if e2.has_attribute("tiny"):
+                return False
+            if not points_are_close(e1.center, e2.center):
+                return False
+            return np.isclose(e1.radius, e2.radius)
+
+        elmts = [(e.p1, e) for e in elements if is_Arc(e) and match(el, e)]
+        elmts.sort()
+
+        ok = False
+        for p, e in elmts:
+            el_new = el.concatenate(None, None, e)
+            if el_new:
+                el.set_attribute("del")
+                e.set_attribute("del")
+                elements.append(el_new)
+                el = el_new
+                ok = True
+        return ok
+
+    def concatenate_line_elements(self, el, elements):
+        if not is_Line(el):
+            return False
+
+        def match(e1, e2):
+            if e2.has_attribute("del"):
+                return False
+            if e2.has_attribute("tiny"):
+                return False
+            return np.isclose(e1.m(999999.0), e2.m(999999.0))
+
+        elmts = [(e.p1, e) for e in elements if is_Line(e) and match(el, e)]
+        elmts.sort()
+
+        ok = False
+        for p, e in elmts:
+            el_new = el.concatenate(None, None, e)
+            if el_new:
+                el.set_attribute("del")
+                e.set_attribute("del")
+                elements.append(el_new)
+                el = el_new
+                ok = True
+        return ok
+
+    def concatenate_tiny_elements(self, new_elements):
+        logger.debug("begin concatenate_tiny_elements")
+        tiny_elements = [e for e in new_elements if e.has_attribute("tiny")]
+        if not tiny_elements:
+            logger.debug("end concatenate_tiny_elements: (%s elements)", 0)
+            return False, new_elements
+
+        count = 0
+        for e_tiny in tiny_elements:
+            if is_Line(e_tiny):
+                if self.concatenate_line_elements(e_tiny, new_elements):
+                    count += 1
+            elif is_Arc(e_tiny):
+                if self.concatenate_arc_elements(e_tiny, new_elements):
+                    count += 1
+
+        new_list = [e for e in new_elements if not e.has_attribute("del")]
+        logger.debug("end concatenate_tiny_elements: (%s elements)", count)
+        return count>0, new_list
+
     def find_symmetry(self, radius,
                       startangle, endangle, sym_tolerance):
         arealist = self.list_of_areas()

femagtools/dxfsl/machine.py

@@ -171,7 +171,8 @@ class Machine(object):
 
     def copy(self, startangle, endangle,
              airgap=False, inside=True, split=False,
-             delete_appendices=False):
+             delete_appendices=False,
+             concatenate_tiny_el=False):
         if airgap and self.airgap_radius > 0.0:
             if inside:
                 if self.airgap2_radius > 0.0:
@@ -182,7 +183,8 @@ class Machine(object):
                                              startangle, endangle,
                                              0.0, new_radius,
                                              split=split,
-                                             delete_appendices=delete_appendices)
+                                             delete_appendices=delete_appendices,
+                                             concatenate_tiny_el=concatenate_tiny_el)
             else:
                 new_radius = self.radius
                 gap_radius = max(self.airgap_radius, self.airgap2_radius)
@@ -190,7 +192,8 @@ class Machine(object):
                                              startangle, endangle,
                                              gap_radius, self.radius+9999,
                                              split=split,
-                                             delete_appendices=delete_appendices)
+                                             delete_appendices=delete_appendices,
+                                            concatenate_tiny_el=concatenate_tiny_el)
 
             circ = Circle(Element(center=self.center,
                                   radius=self.airgap_radius))
@@ -201,7 +204,8 @@ class Machine(object):
                                          startangle, endangle, 0.0,
                                          self.radius+9999,
                                          split=split,
-                                         delete_appendices=delete_appendices)
+                                         delete_appendices=delete_appendices,
+                                         concatenate_tiny_el=concatenate_tiny_el)
 
         if not np.isclose(normalise_angle(startangle),
                           normalise_angle(endangle), 0.0):
@@ -267,10 +271,18 @@ class Machine(object):
     def undo_mirror(self):
         assert(self.is_mirrored())
         assert(self.previous_machine)
-        self.set_alfa_and_corners()
+        self.previous_machine.clear_mirror()
+        self.previous_machine.set_alfa_and_corners()
         self.previous_machine.set_kind(self.geom.kind)
         return self.previous_machine
 
+    def clear_mirror(self):
+        self.mirror_orig_geom = None
+        self.mirror_geom = None
+        self.mirror_startangle = 0.0
+        self.mirror_endangle = 0.0
+        self.geom.mirror_corners = []
+
     def rotate_to(self, new_startangle):
         if np.isclose(new_startangle, self.startangle):
             return
@@ -324,9 +336,12 @@ class Machine(object):
 
         if len(self.airgaps) > 0:
             airgap_candidates = []
+            prv_radius = 0
             for g in self.airgaps:
                 gap_radius = round((g[0]+g[1])/2.0, 6)
                 gap_dist = g[1] - g[0]
+                prv_dist = g[0] - prv_radius
+                prv_radius = g[1]
                 circle = Circle(Element(center=self.center,
                                         radius=gap_radius))
                 ok, borders = self.geom.is_airgap(self.center,
@@ -337,12 +352,10 @@ class Machine(object):
                 if not ok:
                     logger.error("FATAL: No Airgap with radius {}".
                                  format(gap_radius))
-                    print("FATAL: No Airgap with radius {}".
-                          format(gap_radius))
                     self.geom.airgaps.append(circle)
                     return True  # bad exit
 
-                airgap_candidates.append((borders, circle, gap_dist))
+                airgap_candidates.append((borders, circle, gap_dist, prv_dist))
                 self.geom.airgaps.append(circle)
 
                 if correct_airgap > 0.0:
@@ -375,7 +388,7 @@ class Machine(object):
             logger.debug("end airgap: radius=%s", self.airgap_radius)
             return False  # correct airgap set
 
-        gaps = [c for b, c, d in airgap_candidates if b == 0]
+        gaps = [c for b, c, d, prv_d in airgap_candidates if b == 0]
 
         if len(gaps) == 1:  # one candidate without border intersection
             self.airgap_radius = gaps[0].radius
@@ -403,7 +416,7 @@ class Machine(object):
         dist = 999
         circle = None
         pos_list = []
-        for b, c, d in airgap_candidates:
+        for b, c, d, prv_d in airgap_candidates:
             if get_one:
                 logger.info(" --- {}   (width={})".format(c.radius, d))
             else:
@@ -415,10 +428,14 @@ class Machine(object):
             inner_pc = (c.radius - self.geom.min_radius) / \
                        (self.geom.max_radius - self.geom.min_radius)
             pos = np.abs(inner_pc * 100 - 50)
-            logger.debug("Abstand Mitte = {} %".format(pos))
+            logger.debug("Abstand Mitte in % = {}".format(pos))
+            prv_dist_percent = int(round(prv_d / self.geom.max_radius, 2) * 100)
+            logger.debug("Abstand Vorheriger abs=%s in prz=%s (%s)",
+                         prv_d, prv_dist_percent, self.geom.max_radius)
             if pos < 20:
                 pos_list.append([pos, d, c])
-
+            elif prv_dist_percent <= 1:
+                pos_list.append([prv_dist_percent, d, c])
         if get_one:
             if pos_list:
                 dist_list = [[d, c] for pos, d, c in pos_list]
@@ -479,16 +496,29 @@ class Machine(object):
     def repair_hull_geom(self, geom, startangle, endangle):
         logger.debug('begin repair_hull_geom (%s, %s)', startangle, endangle)
 
+        rtol = 1e-4
+        atol = 1e-4
         c_corner = Corner(self.center, self.center)
-        start_corners = geom.get_corner_list(self.center, startangle)
-        end_corners = geom.get_corner_list(self.center, endangle)
+        start_c_added, start_corners = geom.get_corner_list(self.center, startangle,
+                                                            rtol=rtol, atol=atol)
+        end_c_added, end_corners = geom.get_corner_list(self.center, endangle,
+                                                        rtol=rtol, atol=atol)
+        if start_c_added or end_c_added:
+            rtol = 1e-3
+            atol = 1e-3
+            start_c_added, start_corners = geom.get_corner_list(self.center, startangle,
+                                                                rtol=rtol, atol=atol)
+            end_c_added, end_corners = geom.get_corner_list(self.center, endangle,
+                                                            rtol=rtol, atol=atol)
 
         geom.repair_hull_line(self.center,
                               startangle, start_corners,
-                              c_corner in end_corners)
+                              c_corner in end_corners,
+                              rtol=rtol, atol=atol)
         geom.repair_hull_line(self.center,
                               endangle, end_corners,
-                              c_corner in start_corners)
+                              c_corner in start_corners,
+                              rtol=rtol, atol=atol)
         logger.debug('end of repair_hull_geom')
 
     def create_stator_auxiliary_lines(self):
@@ -666,7 +696,8 @@ class Machine(object):
             return None
 
         machine_slice = self.copy(self.geom.symmetry_startangle(),
-                                  self.geom.symmetry_endangle())
+                                  self.geom.symmetry_endangle(),
+                                  concatenate_tiny_el=True)
         machine_slice.clear_cut_lines()
         machine_slice.repair_hull()
         machine_slice.rotate_to(0.0)

femagtools/dxfsl/shape.py

@@ -853,9 +853,11 @@ class Arc(Circle):
         if np.isclose(self.startangle, el.endangle):
             start_angle = el.startangle
             end_angle = self.endangle
-        else:
+        elif np.isclose(el.startangle, self.endangle):
             start_angle = self.startangle
             end_angle = el.endangle
+        else:
+            return None
 
         logger.debug("concatenate_arc: start=%s, end=%s",
                      start_angle,
@@ -1234,8 +1236,20 @@ class Line(Shape):
         return l1, l2
 
     def concatenate_line(self, n1, n2, el):
-        if np.isclose(self.m(999999.0), el.m(999999.0)):
+        if not np.isclose(self.m(999999.0), el.m(999999.0)):
+            return None
+
+        if n1 and n2:
             return Line(Element(start=n1, end=n2))
+
+        if points_are_close(self.p1, el.p1):
+            return Line(Element(start=self.p2, end=el.p2))
+        if points_are_close(self.p1, el.p2):
+            return Line(Element(start=self.p2, end=el.p1))
+        if points_are_close(self.p2, el.p1):
+            return Line(Element(start=self.p1, end=el.p2))
+        if points_are_close(self.p2, el.p2):
+            return Line(Element(start=self.p1, end=el.p1))
         return None
 
     def is_point_inside(self, point,

femagtools/isa7.py

@@ -868,9 +868,17 @@ class Isa7(object):
         except AttributeError:
             pass
 
-        try:
-            el_fe_ind = [np.array(reader.el_fe_induction_1).T/1000,
-                         np.array(reader.el_fe_induction_2).T/1000]
+        try: 
+            flx_fac = 1000
+            if isinstance(reader.el_fe_induction_1, list): 
+                pass
+            else: 
+                if reader.el_fe_induction_1.dtype == 'int16': 
+                    flx_fac = 1000
+                else: 
+                    flx_fac = 1
+            el_fe_ind = [np.array(reader.el_fe_induction_1).T/flx_fac,
+                        np.array(reader.el_fe_induction_2).T/flx_fac]
             eddy_cu_vpot = np.array(reader.eddy_cu_vpot).T/1000
             if len(el_fe_ind[0].shape) == 4:
                 pdim = self.pos_el_fe_induction.shape[0]
@@ -891,8 +899,9 @@ class Isa7(object):
                         n += 1
                     if n > 0:
                         shape.append(n)
-            el_fe_ind = [np.array([[reader.el_fe_induction_1[0][0][:shape[0]]]]).T/1000,
-                         np.array([[reader.el_fe_induction_2[0][0][:shape[0]]]]).T/1000]
+
+            el_fe_ind = [np.array([[reader.el_fe_induction_1[0][0][:shape[0]]]]).T/flx_fac,
+                        np.array([[reader.el_fe_induction_2[0][0][:shape[0]]]]).T/flx_fac]
             eddy_cu_vpot = np.array([[reader.eddy_cu_vpot[0][0][:shape[0]]]]).T/1000
 
         self.el_fe_induction_1 = el_fe_ind[0]

femagtools/machine/__init__.py

@@ -33,7 +33,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     rlfe = lfe
     rwdg = wdg
     opts = {k: eecpars[k] for k in ('zeta1', 'gam', 'kh', 'kpfe',
-                                    'kfric_b') if k in eecpars}
+                                    'kfric_b', 'kpmag') if k in eecpars}
     try:
         opts['rotor_mass'] = rlfe*eecpars['rotor_mass']
     except KeyError:

femagtools/machine/effloss.py

@@ -309,7 +309,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     if isinstance(m, (PmRelMachine, SynchronousMachine)):
         plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
         plfe2 = m.kpfe*m.iqd_plfe2(iqd[0], iqd[1], f1)
-        plmag = m.iqd_plmag(iqd[0], iqd[1], f1)
+        plmag = m.kpmag*m.iqd_plmag(iqd[0], iqd[1], f1)
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], 2*np.pi*f1)
         plcu2 = m.iqd_plcu2(*iqd)
         tfric = m.tfric

femagtools/machine/pm.py

@@ -203,7 +203,7 @@ class PmRelMachine(object):
         if n > 1e-3:
             f1 = self.p*n
             plfe = self.kpfe * (self.iqd_plfe1(iq, id, f1) + self.iqd_plfe2(iq, id, f1))
-            pmag = self.iqd_plmag(iq, id, f1)
+            pmag = self.kpmag * self.iqd_plmag(iq, id, f1)
             return (plfe + pmag + self.pfric(n))/(2*np.pi*n)
         return 0
 
@@ -1261,7 +1261,14 @@ class PmRelMachineLdq(PmRelMachine):
         return self.betai1_plfe2(*betai1(iq, id), f1)
 
     def betai1_plmag(self, beta, i1, f1):
-        return self._losses['magnet'](beta, i1)*(f1/self.fo)**2
+        r = self._losses['magnet'](beta, i1)*(f1/self.fo)**2
+        try:
+            idx = np.argwhere(r < 0)
+            if len(idx.squeeze()): 
+                r[idx.squeeze()] = 0.0
+        except: 
+            pass 
+        return r
 
     def iqd_plmag(self, iq, id, f1):
         return self.betai1_plmag(*betai1(iq, id), f1)

femagtools/machine/sm.py

@@ -546,7 +546,7 @@ class SynchronousMachine(object):
             w10)[0]
 
     def characteristics(self, T, n, u1max, nsamples=50,
-                        with_tmech=True, with_torque_corr=False):
+                        with_tmech=True, with_torque_corr=False, **kwargs):
         """calculate torque speed characteristics.
         return dict with list values of
         n, T, u1, i1, beta, cosphi, pmech, n_type

femagtools/utils.py

@@ -17,7 +17,7 @@ def fft(pos, y, pmod=0):
     else:
         #negative_periodic = np.abs(y[0] - y[-1])/np.max(y) > 1
         # count zero crossings
-        ypos = np.asarray(y) > 0
+        ypos = np.asarray(y[:-1]) > 0
         nypos = ~ypos
         nzc = len(((ypos[:-1] & nypos[1:])
                    | (nypos[:-1] & ypos[1:])).nonzero()[0])
@@ -40,12 +40,12 @@ def fft(pos, y, pmod=0):
     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])
+    freq = np.fft.fftfreq(N, d=360/N)
     nmax = min(18*ntiles, N//2)
     T0 = 0
     if abs(freq[i]) > 0:
         T0 = np.abs(1/freq[i])
-        npoles = 2*int(np.ceil(360/T0))
+        npoles = 2*int(360/T0)
         nmax = min(9*npoles, N//2)
 
     alfa0 = np.angle(Y[i])

{femagtools-1.6.0.dist-info → femagtools-1.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: femagtools
-Version: 1.6.0
+Version: 1.6.2
 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.6.0.dist-info → femagtools-1.6.2.dist-info}/RECORD

@@ -1,9 +1,9 @@
-femagtools/__init__.py,sha256=R-39ZdZxxAmDeGzV4v9pKcYF3Wpacyx6PJMK6Zk8WdA,1615
+femagtools/__init__.py,sha256=UUpTqpPxTE9-KNmWFDhqdB2Sy56sR68HZdRSYl0X3BA,1615
 femagtools/airgap.py,sha256=ZCIZTYf6BbuNYx68y9fUDBQo3taN8RuGl8q-jJ7ygiA,1577
 femagtools/amazon.py,sha256=O1ICuv21XDAJi1qK1Sigs2TdS6hDZP19OzvmE2t76wU,12069
 femagtools/amela.py,sha256=pHjfXzpANI-7oz8MtrqNcyDZ6PxVM91vCJuvYhHy1rk,13891
 femagtools/asm.py,sha256=CiL0KWaF4P7O6-VwmGLdva_icwmPrPiI-TFQ19XYTKk,7660
-femagtools/bch.py,sha256=5WTs9YjSj-XRFqXeHdf5Ps3jECwn_5-5j6QoVMDqWdE,70841
+femagtools/bch.py,sha256=lw90KDHoC2NNHLYBupUXrJQRt-8yDeV-7usH4ZwkFJk,71680
 femagtools/bchxml.py,sha256=KrRjAdrUPZXmiWvonu9HhpG_NvImMBpiXWTL4iSr4kE,3142
 femagtools/condor.py,sha256=J8z9iBdvrGu3I1eFNoyKV8AXzRoTEPGLSak6cXUQxAM,10766
 femagtools/conductor.py,sha256=rXO7c7Qh_s7JpgILmLd4IbG64vP6Eh143YF9u25Mdwg,1076
@@ -23,7 +23,7 @@ femagtools/gmsh.py,sha256=IKhNiviIBji4cMxAhxaYXNqBRMNAPSKsBGdnGyxkyQw,3903
 femagtools/google.py,sha256=ugRyHY1zBjHR4aNfbA7GeF-ZU_NgleuVTZaWpi_XLT4,17144
 femagtools/grid.py,sha256=s7LfKKLm2H4-cza2kSEANq6vwxq10Su3TJl3kHShHRA,1561
 femagtools/hxy.py,sha256=PkiZ_-CRhtvtpkmLAP8iMtwvzh7CjKGGcAbOhFb4Nls,6275
-femagtools/isa7.py,sha256=5v0f2wF9quf3ZTFSbLnQuQW1kIETvVwSVHwhMi0PNTk,58044
+femagtools/isa7.py,sha256=cUZx9fpxZgkw2G-cnveR-X-_lWP7Z1Q88MCysLl9MFI,58336
 femagtools/jhb.py,sha256=stJxkmzHpfUIBVcFw7jWbV5KN9_EFqzOCgacyhUqWvM,1779
 femagtools/job.py,sha256=dOatzr10nIda76CjVRSS0SfEWC8_BAw0kowli523qbY,11320
 femagtools/losscoeffs.py,sha256=dlSYDS13RqpPHLdv_EPWIA9liwhqjbxUiN7t7GFPZhw,5397
@@ -42,29 +42,29 @@ femagtools/parstudy.py,sha256=oP6ukKBCcAjwPK_DzbUEmo5ay2TINamao2aV42FbgP8,18799
 femagtools/poc.py,sha256=MN5DRL4vHycNzXSTt9kjuZP1yZ2I02NmrKQFsmRcbF0,6536
 femagtools/tks.py,sha256=FuEKiWcSnOW2Hp2NxCq1hBeQdRFkHutaJuctrhxh8Ws,6228
 femagtools/ts.py,sha256=x9aCMVASjdBZuyI2pJGMyi1dveGFd_pWQ20cZ-l_moc,47216
-femagtools/utils.py,sha256=W7RuLLnSIMqfhHi2UmY_W7bM6zLOJ7CUo_mFZnfB14w,1593
+femagtools/utils.py,sha256=1SX5s21xyW8u0NF_Hjs7DByyCTdLm9VRArLburTyHR0,1581
 femagtools/vbf.py,sha256=9XGfhftmD9carU8ByQ5DwqoR4daq5mJ39eMqruwml0Q,2444
 femagtools/vtu.py,sha256=Sf83dHIfCKY2km-MIUHKKoj-JKN4PDX7kkPLZXyIYY4,10723
 femagtools/windings.py,sha256=6ioABZRWQ3xA4kmEz2NUkXh-C-FmW9YYkjQKs5YakQs,22197
 femagtools/dxfsl/__init__.py,sha256=MywcCdpKPKs4qJBJJgeDsikJFJ2P48dbTuNk303f5pM,76
 femagtools/dxfsl/area.py,sha256=ohs6J_X-c6y-FrSd2LFjMc3024N9RcOpDKgsXIsuoNs,57818
-femagtools/dxfsl/conv.py,sha256=xOCj0vPlyRVP1FVNPLtKx_Fe88emjaht_DD4bfycD6A,8990
+femagtools/dxfsl/conv.py,sha256=j17gjZ7XjoP6QmEO50ZMA-jyYrcMQEgpDH0hZN26RbM,9236
 femagtools/dxfsl/converter.py,sha256=6BCwlVp0PiSZ4Wj-YDgl7ynWNN2SBuwxw5VnNQ55Y9w,20821
 femagtools/dxfsl/corner.py,sha256=UI1MLlVmiTBURywsOnXnXV7eBABoENc6ortkW_3GYH8,1266
 femagtools/dxfsl/dumprenderer.py,sha256=n4AvInjvGIaC2iKZtQaYXXDyJVSQ3uEOFOLD4-xfKRY,1861
 femagtools/dxfsl/fslrenderer.py,sha256=C4oonLPzKb_9IKvpm-fMvbhQZqtP_7xWG5bzpq8P1CY,23377
-femagtools/dxfsl/functions.py,sha256=Y861cXEWTLVpC5iKOSDqRQ4Idbk4OqQQD-qFK-s8_20,10107
-femagtools/dxfsl/geom.py,sha256=DELZXyCOpaNUmzOoL5NHQi9kjtq0qXc4Ry26G2_KHgg,160283
-femagtools/dxfsl/machine.py,sha256=sK4N8JHEqxZ-gHWKjlInezxEhTHpFAkopGvUaqAsjgg,40429
+femagtools/dxfsl/functions.py,sha256=5G1MSAVaC4NOpQ_YBZ1SHPsmnvbQsnmg3rLjN3d5mBs,11463
+femagtools/dxfsl/geom.py,sha256=bAZtk_GIO7anaBeZKZhWHGyt9L-t_F1YglCgRc0oU48,163051
+femagtools/dxfsl/machine.py,sha256=ftqLiwCyrzekUSvAOVD9AIM4hrPrIpId7PhLKwvSpWs,42158
 femagtools/dxfsl/plotrenderer.py,sha256=dIOM8p3UNTlqypxuPcLCegOaK19j3-ahelZ8hneLJ6k,12710
-femagtools/dxfsl/shape.py,sha256=H18nAtoOladnQIM-XKiIDHFpZbls4cs5cVJ-j7yAriM,47755
-femagtools/machine/__init__.py,sha256=xMypyugPeEe7qHBAn2UWjiHdVYYfP6eoO56k1ZIEBss,7165
+femagtools/dxfsl/shape.py,sha256=4onAfXaVUWxC9C2WXVLYi3UH6w2lhUHxuLjdFgQOqks,48302
+femagtools/machine/__init__.py,sha256=U8W65K7jr7jDdC1KnJh0WjYd8DFaLnIFVvlh-TKcV94,7174
 femagtools/machine/afpm.py,sha256=hNyDFRLGmCuWRPZl_u1ztJ4pA-Y_mxLaVvg3UJkzRuE,24766
-femagtools/machine/effloss.py,sha256=aaSmmxKd_KWMasHUHipYDcZOw-fvTHNa38MWFnpVock,13130
+femagtools/machine/effloss.py,sha256=I8s2Fog6klhgcRYw3448qfGvzaQ0AQUJXFdNoeDyhfE,13138
 femagtools/machine/im.py,sha256=ScIOLrlc4CPLYFNx2MmJqkpmbky_HXxFGZbMWUNGBrk,37881
-femagtools/machine/pm.py,sha256=cGOdcUzMyBYJotQB8_tj93_2pwK9tml4GuSet80HgnM,56042
+femagtools/machine/pm.py,sha256=R8RWzQrMI_fNaUU7ruHnQxg3-Lubh1vp-6EG6z5QbRk,56229
 femagtools/machine/sizing.py,sha256=aN_OahewjTTBHnpRNfLh1AGFhqnoeZVuMBeb_3MCIVI,23096
-femagtools/machine/sm.py,sha256=hfJA8_C-uuDIKnjR12H9LkVocxnNoSkJaH2R_-8-2zQ,34310
+femagtools/machine/sm.py,sha256=pkik913kU41PPiUpwDy_6BEKfCIhvY6FEp-fbU2Lqew,34320
 femagtools/machine/utils.py,sha256=g9q4j9KxUWdb_iUOUQDuaAwwJx8XM0kZMpgnwsNz8hU,18616
 femagtools/moo/__init__.py,sha256=zinmWEOrsEz6DmMX0Dbn4t6_1UR-p4bEGqyR1wUQk_Q,175
 femagtools/moo/algorithm.py,sha256=lNEf0Bur4yFpIJeLtAC3oIus8sOMWTb7jepFlD28YzE,5445
@@ -200,9 +200,9 @@ tests/moo/__init__.py,sha256=l8HD-AY8EwxOoo_VrG3HgEZb2MaHypvnhKCVSkR-DTA,808
 tests/moo/test_algorithm.py,sha256=Em8sFm2vzPmuIzRrBBnUQLU_TYuJHSf-kEeozw0XeX4,2563
 tests/moo/test_population.py,sha256=FvX9LRCxQx0_E2GxHQ5vKwOYFBQiNbT6Lmv5GmNWjTQ,5471
 tests/moo/test_problem.py,sha256=ALeP4u7g-dFhfwWL8vxivdrrYzVKPjHMCAXzzgyNZbs,467
-femagtools-1.6.0.dist-info/LICENSE,sha256=V5OED7AzEaOtvbfgNheKOSUeNtijvKQuo84FtSJNkJU,1316
-femagtools-1.6.0.dist-info/METADATA,sha256=D6-oFfERwRA-hlS9Pyjw6fqyz_Dsl9Q7htgd5-VcmR4,5685
-femagtools-1.6.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-femagtools-1.6.0.dist-info/entry_points.txt,sha256=UXpu6KnrykN89sCUaFAIIzn_dYwuxizUS0GcPdoekro,195
-femagtools-1.6.0.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.6.0.dist-info/RECORD,,
+femagtools-1.6.2.dist-info/LICENSE,sha256=V5OED7AzEaOtvbfgNheKOSUeNtijvKQuo84FtSJNkJU,1316
+femagtools-1.6.2.dist-info/METADATA,sha256=_Fn2D61D0C-a96X_49iBhYauUSoeaM6AAR28-QDL1is,5685
+femagtools-1.6.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+femagtools-1.6.2.dist-info/entry_points.txt,sha256=UXpu6KnrykN89sCUaFAIIzn_dYwuxizUS0GcPdoekro,195
+femagtools-1.6.2.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
+femagtools-1.6.2.dist-info/RECORD,,