femagtools 1.6.4__py3-none-any.whl → 1.6.6__py3-none-any.whl

femagtools/dxfsl/svgparser.py

@@ -0,0 +1,90 @@
+"""
+
+Geometry Parser for SVG files
+
+"""
+import logging
+import re
+import lxml.etree as ET
+from .shape import Circle, Arc, Line, Element
+import numpy as np
+
+logger = logging.getLogger(__name__)
+
+def get_center(r, p1, p2, sweep):
+    """return center point coordinates of arc"""
+    dp = p2-p1
+    s = np.linalg.norm(dp)
+    delta = np.arctan2(dp[1], dp[0])
+    if s < 2*r:
+        if sweep == 0:
+            alfa = delta - np.arctan2(np.sqrt(r**2-s**2/4), s/2)
+        else:
+            alfa = delta + np.arctan2(np.sqrt(r**2-s**2/4), s/2)
+    else:
+        alfa = delta
+    return p1[0] + r*np.cos(alfa), p1[1] + r*np.sin(alfa)
+
+
+def get_angles(sweep, center, p1, p2):
+    x1, y1 = (p1-center)
+    x2, y2 = (p2-center)
+    if sweep == 0:
+        return np.arctan2(y2, x2), np.arctan2(y1, x1)
+    return np.arctan2(y1, x1), np.arctan2(y2, x2)
+
+
+def get_shapes(path):
+    """return list of node elements (A, L)"""
+    state = ''
+    p = []
+    for s in [s for s in re.split('([AML])|,|\\s+',path) if s]:
+        if state == '':
+            state = s[0]
+        elif state == 'M':
+            p.append(float(s))
+            if len(p) == 2:
+                p1 = np.array(p)
+                p = []
+                state = ''
+        elif state == 'L':
+            p.append(float(s))
+            if len(p) == 2:
+                p2 = np.array(p)
+                logger.debug("Line %s -> %s",
+                            p1, p2)
+                yield Line(Element(start=p1, end=p2))
+                p1 = p2.copy()
+                p = []
+                state = ''
+        elif state == 'A':
+            p.append(float(s))
+            if len(p) == 7:
+                sweep = int(p[-3])
+                p2 = np.array(p[-2:])
+                r = p[0]
+                center = get_center(r, p1, p2, sweep)
+                start, end = get_angles(sweep, center, p1, p2)
+                logger.debug("Arc center %s r %f %f -> %f",
+                            center, r, start, end)
+                yield Arc(Element(center=center,
+                                  radius=r,
+                                  start_angle=start*180/np.pi,
+                                  end_angle=end*180/np.pi))
+                p1 = p2.copy()
+                p = []
+                state = ''
+        else:
+            raise ValueError(f"unsupported path {state}")
+
+
+def svgshapes(svgfile):
+    svg = ET.parse(svgfile)
+    for p in svg.findall(".//{http://www.w3.org/2000/svg}path"):
+        yield from get_shapes(p.get('d'))
+    for p in svg.findall(".//{http://www.w3.org/2000/svg}line"):
+        yield Line(Element(start=[float(p.get('x1')), float(p.get('y1'))],
+                           end=[float(p.get('x2')), float(p.get('y2'))]))
+    for p in svg.findall(".//{http://www.w3.org/2000/svg}circle"):
+        center = float(p.get('cx')), float(p.get('cy'))
+        yield Circle(Element(center=center, radius=float(p.get('r'))))

femagtools/dxfsl/symmetry.py

@@ -0,0 +1,370 @@
+# -*- coding: utf-8 -*-
+"""
+  femagtools.dxfsl.symmetry
+  ~~~~~~~~~~~~~~~~~~~~~~~~~
+
+  Authors: Ronald Tanner, Beat Holm
+"""
+from __future__ import print_function
+
+import numpy as np
+import logging
+import sys
+from femagtools.dxfsl.shape import Element, Line
+from femagtools.dxfsl.area import Area
+from femagtools.dxfsl.functions import alpha_angle, positive_angle, is_same_angle
+from femagtools.dxfsl.functions import min_angle, max_angle, gcd, point
+from femagtools.dxfsl.functions import less_equal, less, points_are_close
+from femagtools.dxfsl.functions import line_m, line_n, mirror_point
+
+logger = logging.getLogger('femagtools.symmetry')
+
+
+#############################
+#         symmetry          #
+#############################
+
+
+class Symmetry(object):
+    def __init__(self,
+                 geom=None,
+                 startangle=None,
+                 endangle=None,
+                 rtol=1e-04,
+                 atol=1e-03):
+        assert(geom is not None)
+        assert(startangle is not None)
+        assert(endangle is not None)
+        
+        self.geom = geom
+        self.startangle = startangle
+        self.endangle = endangle
+        self.delta_check_count = 0
+        self.delta_angle_korr = 0.0
+        self.rtol = rtol
+        self.atol = atol
+        self.full = False
+        if np.isclose(self.startangle, self.endangle):
+            self.alpha = 2.0*np.pi
+            self.full = True
+        else:
+            self.alpha = alpha_angle(self.startangle, self.endangle)
+            self.full = False
+        logger.debug("Symmetry(alpha=%s, rtol=%s, atol=%s)", self.alpha, rtol, atol)
+
+    def __str__(self):
+        return "rtol: {}\n".format(self.rtol) + \
+               "atol: {}\n".format(self.atol)
+
+    def equal_area(self,
+                   d1, h1, a1,
+                   d2, h2, a2,
+                   rtol=1e-03, atol=1e-03):
+        if not np.isclose(d1, d2, rtol=rtol, atol=atol):
+            logger.debug("dist NOT close (%s/%s)", d1, d2)
+            return False
+        if not np.isclose(h1, h2, rtol=rtol, atol=atol):
+            logger.debug("height NOT close (%s/%s)", h1, h2)
+            return False
+        if not np.isclose(a1, a2, rtol=rtol, atol=atol):
+            logger.debug("alpha NOT close (%s/%s)", a1, a2)
+            return False
+        return True
+
+    def calc_mid_angle(self, a):
+        return positive_angle(alpha_angle(self.startangle,
+                                          a.get_mid_angle(self.geom.center)))
+
+    def find_symmetry(self):
+        arealist = self.geom.list_of_areas()
+        logger.debug("begin of Symmetry::find_symmetry: %s areas available", len(arealist))
+        if len(arealist) == 0:
+            logger.debug("end of find_symmetry: no areas")
+            return 0
+
+        areas = []
+        for a in arealist:
+            areas.append((round(a.get_alpha(self.geom.center), 3),
+                          round(a.min_dist, 1),
+                          round(a.height, 1),
+                          self.calc_mid_angle(a),
+                          a))
+        areas.sort(reverse=True)
+
+        a0_alpha, a0_min_dist, a0_height, a0_mid_angle, a0 = areas[0]
+        equal_areas = [(a0_mid_angle, a0)]
+        check_rslt = []
+        for a1_alpha, a1_min_dist, a1_height, a1_mid_angle, a1 in areas[1:]:
+            if self.equal_area(a0_min_dist, a0_height, a0_alpha,
+                               a1_min_dist, a1_height, a1_alpha,
+                               rtol=0.01, atol=0.05):
+                a0_min_dist = (a0_min_dist + a1_min_dist) / 2
+                a0_height = (a0_height + a1_height) / 2
+                a0_alpha = (a0_alpha + a1_alpha) / 2
+                equal_areas.append((a1_mid_angle, a1))
+            else:
+                parts = self.check_delta(equal_areas)
+                check_rslt.append((a0.area_size(), parts, len(equal_areas), a0))
+
+                equal_areas = [(a1_mid_angle, a1)]
+                a0_min_dist = a1_min_dist
+                a0_height = a1_height
+                a0_alpha = a1_alpha
+                a0 = a1
+
+        parts = self.check_delta(equal_areas)
+        check_rslt.append((a0.area_size(), parts, len(equal_areas), a0))
+
+        parts = self.get_symmetry_parts(check_rslt)
+        if parts < 2:
+            logger.debug("end of Symmetry::find_symmetry: no symmetry")
+            return parts
+
+        self.geom.clear_cut_lines()
+        for alpha in self.symmetry_lines(parts,
+                                         self.startangle,
+                                         self.endangle):
+            plus = self.geom.max_radius / 10
+            min_radius = max(10, self.geom.min_radius - plus)
+            p1 = point(self.geom.center, min_radius, alpha)
+            p2 = point(self.geom.center, self.geom.max_radius + plus, alpha)
+            line = Line(Element(start=p1, end=p2))
+            line.init_attributes(color='green')
+            self.geom.add_cut_line(line)
+
+        logger.debug("end of Symmetry::find_symmetry: -> %s", parts)
+        return parts
+    
+    def check_delta(self, area_list):
+        logger.debug("begin of check_delta: %s equal areas", len(area_list))
+        if not area_list:
+            logger.debug("end of check_delta: no areas")
+            return None
+
+        if len(area_list) == 1:
+            mid_angle, a = area_list[0]
+            alpha = a.get_alpha(self.geom.center)
+            if np.isclose(alpha, self.alpha):
+                logger.debug("end of check_delta: one area from start to end")
+                return None  # ok
+
+        self.delta_check_count += 1
+        area_list.sort()
+
+        mid_angle, a = area_list[0]
+        delta = positive_angle(mid_angle * 2)
+        delta_total = mid_angle
+        delta_list = [delta]
+
+        logger.debug("First mid = %s, delta = %s", mid_angle, delta)
+        logger.debug("%s:  d=%s,  h=%s,  a=%s, mid=%s, delta=%s",
+                     a.identifier(),
+                     a.min_dist,
+                     a.height,
+                     a.get_alpha(self.geom.center),
+                     mid_angle,
+                     delta)
+
+        geom_alpha = alpha_angle(self.startangle, self.endangle)
+        geom_alpha = positive_angle(geom_alpha)
+
+        start_angle = mid_angle
+        for mid_angle, a in area_list[1:]:
+            delta_angle = alpha_angle(start_angle, mid_angle)
+            delta = positive_angle(delta_angle)
+            delta_total += delta_angle
+            delta_list.append(delta)
+
+            logger.debug("%s:  d=%s,  h=%s,  a=%s, mid=%s, delta=%s",
+                         a.identifier(),
+                         a.min_dist,
+                         a.height,
+                         a.get_alpha(self.geom.center),
+                         mid_angle,
+                         delta)
+            start_angle = mid_angle
+            
+        delta_angle = alpha_angle(start_angle, geom_alpha)
+        delta = positive_angle(delta_angle * 2)
+        delta_total += delta_angle
+        delta_list.append(delta)
+        logger.debug("final delta=%s", delta)
+
+        if not np.isclose(geom_alpha, delta_total):
+            logger.debug("-- deltas: %s", delta_list)
+            logger.debug("end of check_delta: BAD DELTA %s, (expected %s)",
+                         delta_angle, geom_alpha)
+            return 0  # very bad
+
+        sz = len(delta_list)
+        mid = int(sz / 2)
+        ix1 = 0
+        ix2 = sz - 1
+        first_last_bad = False
+        for ix1 in range(0, mid):
+            if not np.isclose(delta_list[ix1], delta_list[ix2], rtol=1e-3, atol=1e-3):
+                if self.full and \
+                   self.delta_check_count == 1 and \
+                   ix1 == 0 and \
+                   self.delta_angle_korr == 0.0:
+                    first_last_bad = True
+                else:
+                    logger.debug("end of check_delta: NO SYM")
+                    return 0
+            ix2 -= 1
+
+        if first_last_bad:
+            delta_korr = (delta_list[0] + delta_list[-1]) / 2.0
+            logger.debug("STARTANGLE CORRECTION")
+            self.delta_angle_korr = (delta_korr - delta_list[0]) / 2
+            logger.debug("-- delta[0] from %s to %s", delta_list[0], delta_korr)
+            logger.debug("Delta Angle Korr = %s", self.delta_angle_korr)
+            delta_list[0] = delta_korr
+            delta_list[-1] = delta_korr
+            assert(self.full)
+            self.startangle = self.startangle - self.delta_angle_korr
+            self.endangle = self.endangle - self.delta_angle_korr
+            logger.debug("New startangle = %s", self.startangle)
+            logger.debug("Delta List: %s", delta_list)
+
+        d1 = delta_list[0]
+        d1_count = 1
+        inx_list = [0]
+        for x in range(1, len(delta_list)):
+            if np.isclose(d1, delta_list[x], rtol=1e-3, atol=1e-3):
+                inx_list.append(x)
+                d1_count += 1
+
+        if d1_count == len(delta_list):
+            logger.debug("end of check_delta: SYMMETRY FOUND")
+            return d1_count -1  # very simple
+        if len(delta_list) < 2:
+            logger.debug("end of check_delta: One delta only ?!")
+            return 0
+
+        logger.debug("index of delta %s = %s", d1, inx_list)
+        x1 = inx_list[0]
+        x2 = inx_list[1]
+        step = x2 - x1
+        x1 = x2
+        for x2 in inx_list[2:]:
+            if not (x2 - x1 == step):
+                return 0
+            x1 = x2
+        
+        logger.debug("end of check_delta: SYMMETRY FOUND")
+        return len(inx_list) -1
+
+    def get_symmetry_parts(self, check_rslt):
+        max_size = 0
+        max_areas = 0
+        parts_possible = None
+
+        check_rslt.sort(reverse=True)
+        for size, parts, count, area in check_rslt:
+            logger.debug("Result: %s, %s, %s", size, parts, count)
+
+        for size, parts, count, area in check_rslt:
+            if parts is not None and parts > 0:
+                max_size = max(max_size, size)
+                max_areas = max(max_areas, count)
+
+        logger.debug("max size: %s,  max areas: %s", max_size, max_areas)
+
+        for size, parts, count, area in check_rslt:
+            if parts is not None and parts <= 1:  # critical
+                if count <= max(1, max_areas / 5):
+                    if size < max_size / 25:
+                        parts = None
+
+            parts_possible = self.calc_parts(parts_possible, parts)
+
+        if parts_possible is None:
+            parts_possible = 0
+        return parts_possible
+
+    def calc_parts(self, parts1, parts2):
+        logger.debug("Calc symmetry Parts (%s, %s)", parts1, parts2)
+        if parts2 is None:
+            logger.debug("return %s parts", parts1)
+            return parts1
+        if parts1 is None:
+            logger.debug("return %s parts", parts2)
+            return parts2
+        if parts1 == 0 or parts2 == 0:
+            logger.debug("return %s parts", 0)
+            return 0
+        parts = gcd(parts1, parts2)
+        logger.debug("return %s parts", parts)
+        return parts
+
+    def symmetry_lines(self, parts, startangle, endangle):
+        logger.debug("begin symmetry_lines from %s to %s",
+                     startangle,
+                     endangle)
+        if less_equal(endangle, startangle):
+            endangle += 2*np.pi
+
+        delta = alpha_angle(startangle, endangle) / parts
+        start = startangle + delta
+        while less(start, endangle):
+            yield start
+            start += delta
+
+        if is_same_angle(startangle, endangle):
+            yield start
+
+        # Damit man anschliessend ohne Umstände schneiden kann.
+        self.geom.sym_startangle = startangle
+        self.geom.sym_endangle = startangle + delta
+        self.geom.sym_slices = parts
+        self.geom.sym_slice_angle = delta
+        self.geom.sym_area = Area([], (0,0), 0.0)
+        self.geom.sym_area.sym_startangle = self.geom.sym_startangle
+        self.geom.sym_area.sym_endangle = self.geom.sym_endangle
+        logger.debug("end symmetry_lines")
+
+    def check_symmetry_of_mirror(self, mirror_geom, mirrorangle):
+        logger.debug("begin of Symmetry::check_symmetry_of_mirror")
+        assert(mirror_geom is not None)
+
+        axis_p = point(self.geom.center, self.geom.max_radius, mirrorangle)
+        axis_m = line_m(self.geom.center, axis_p)
+        axis_n = line_n(self.geom.center, axis_m)
+
+        def counterpart_found(node, nodes, rtol, atol):
+            hits = 0
+            for n in nodes:
+                if points_are_close(node, n, rtol, atol):
+                    logger.debug(" ---- %s is %s", node, n)
+                    return True
+            return False
+
+        def check_differences(geom, mirror_geom):
+            geom_ag_nodes = []
+            geom_nodes = [n for n in geom.g.nodes() if not (n in geom_ag_nodes)]
+
+            hit = 0
+            for n in geom_nodes:
+                mirror_n = mirror_point(n, geom.center, axis_m, axis_n)
+                if counterpart_found(mirror_n,
+                                     mirror_geom.g.nodes(),
+                                     self.rtol,
+                                     self.atol):
+                    hit += 1
+            min_nodes = min(len(geom_nodes), int(len(geom_nodes) * 0.95) + 1)
+            logger.debug("Nodes=%s,  Counterparts=%s", len(geom_nodes), hit)
+            if hit < min_nodes:
+                return hit / len(geom_nodes)
+            else:
+                return 1.0
+
+        # ----------------
+        logger.debug("check geom - mirror")
+        f1 = check_differences(self.geom, mirror_geom)
+        logger.debug("check mirror - geom")
+        f2 = check_differences(mirror_geom, self.geom)
+        logger.debug("Factor 1: %s,  2: %s", f1, f2)
+        ok = f1 > 0.97 and f2 > 0.97
+        logger.debug("end of Symmetry::check_symmetry_of_mirror => %s", ok)
+        return ok

femagtools/isa7.py

@@ -868,14 +868,14 @@ class Isa7(object):
         except AttributeError:
             pass
 
-        try: 
+        try:
             flx_fac = 1000
-            if isinstance(reader.el_fe_induction_1, list): 
+            if isinstance(reader.el_fe_induction_1, list):
                 pass
-            else: 
-                if reader.el_fe_induction_1.dtype == 'int16': 
+            else:
+                if reader.el_fe_induction_1.dtype == 'int16':
                     flx_fac = 1000
-                else: 
+                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]
@@ -1432,6 +1432,7 @@ class Element(BaseEntity):
         """return temperature of this element"""
         return sum([v.vpot[1] for v in self.vertices])/len(self.vertices)
 
+
 class SuperElement(BaseEntity):
     def __init__(self, key, sr_key, elements, nodechains, color,
                  nc_keys, mcvtype, condtype, conduc, length,

femagtools/machine/effloss.py

@@ -238,7 +238,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
                                    with_pmconst=with_pmconst, with_tmech=with_tmech)  # braking mode
     
     if kwargs.get('mesh_func', 0):
-        ntmesh = kwargs['mesh_func'](r['n'], r['T'],
+        ntmesh = kwargs['mesh_func'](r['n_type'], r['n'], r['T'],
                                     rb['n'], rb['T'], npoints)
     else: 
         ntmesh = _generate_mesh(r['n'], r['T'],

femagtools/machine/im.py

@@ -63,7 +63,7 @@ def ring_leakage_inductance(machine):
     mue0 = 4*np.pi*1e-7
 
     Qr = machine['rotor']['num_slots']
-    m = machine['winding']['num_phases']
+    m = machine['windings']['num_phases']
     p = machine['poles']//2
     lbar = machine['lfe']
     ls = lbar
@@ -622,6 +622,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
     i_max_fact: (float) factor for maximum current to calculate no_load flux (default=2.5)
     templatedirs: (list of str) names of directories to search for templates
     """
+    cmd = kwargs.get("cmd", None)
     CON = {'open': 0, 'wye': 1, 'star': 1, 'delta': 2}
     p = machine['poles']//2
     slip = 1e-2
@@ -676,7 +677,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
 
     parstudy = femagtools.parstudy.ParameterStudy(
         workdir, condMat=condMat,
-        magnetizingCurves=magnetizingCurves)
+        magnetizingCurves=magnetizingCurves, cmd=cmd)
 
     builder = femagtools.fsl.Builder(kwargs.get('templatedirs', []))
     model = femagtools.model.MachineModel(m)

femagtools/machine/pm.py

@@ -69,6 +69,7 @@ class PmRelMachine(object):
         self.rotor_mass = 0
         self.kth1 = KTH
         self.bertotti = False
+        self.max_torque = 0.0
         self.losskeys = ['styoke_hyst', 'stteeth_hyst',
                         'styoke_eddy', 'stteeth_eddy',
                         'rotor_hyst', 'rotor_eddy',
@@ -165,6 +166,46 @@ class PmRelMachine(object):
         return iq, 0, self.torque_iqd(iq, 0)
 
     def iqd_tmech(self, torque, n, iqd0=0, with_mtpa=True):
+        """return minimum d-q-current for shaft torque"""
+        if np.abs(torque) < 1e-2:
+            return (0, 0)
+        if np.isscalar(iqd0):
+            tx = self.tmech_iqd(self.io[0], 0, n)
+            iq0 = min(0.9*self.i1range[1]/np.sqrt(2),
+                      np.abs(torque)/tx*self.io[0])
+            if torque < 0:
+                i0 = (-iq0, 0)
+            else:
+                i0 = (iq0, 0)
+            logger.debug("initial guess i0 %f -> %s tx %f torque %f",
+                        self.io[0], i0, tx, torque)
+        else:
+            i0 = iqd0
+
+        if with_mtpa:
+            k=0
+            while k < 6:
+                res = so.minimize(
+                    lambda iqd: la.norm(iqd), i0, method='SLSQP',
+                    constraints=({'type': 'eq',
+                                  'fun': lambda iqd:
+                                  self.tmech_iqd(*iqd, n) - torque}))
+                if res.success:
+                    return res.x
+                # make new initial guess:
+                tx = self.tmech_iqd(*i0, n)
+                logger.debug("k %d new guess i0 %s tx %f torque %f",
+                            k, i0, tx, torque)
+                i0=(min(0.9*self.i1range[1]/np.sqrt(2), torque/tx*i0[0]), 0)
+                k += 1
+            raise ValueError(
+                f'Torque {torque} speed {n} {i0} {res.message}')
+        def tqiq(iq):
+            return torque - self.tmech_iqd(float(iq), 0, n)
+        iq = so.fsolve(tqiq, (i0[0],))[0]
+        return iq, 0, self.tmech_iqd(iq, 0, n)
+
+    def iqd_tmech0(self, torque, n, iqd0=0, with_mtpa=True):
         """return minimum d-q-current for shaft torque"""
         if np.abs(torque) < 1e-2:
             return (0, 0)
@@ -681,17 +722,24 @@ class PmRelMachine(object):
             iq, id, T = self.mtpa(i1max)
             w1type = self.w1_umax(u1max, iq, id)
         Pmax = w1type/self.p*T
-        w1max = 2*np.pi*speedmax*self.p
         # check max speed:
-        if with_pmconst:
-            iq, id, tq = self.iqd_pmech_imax_umax(
-                speedmax, Pmax, i1max, u1max,
-                with_mtpa, with_tmech)
-        else:
-            iq, id, tq = self.iqd_imax_umax(
-                i1max, w1max, u1max,
-                T, with_mtpv=False,
-                with_tmech=with_tmech)
+        sp = speedmax
+        while sp > w1type/2/np.pi/self.p:
+            w1max = 2*np.pi*sp*self.p
+            try:
+                if with_pmconst:
+                    iq, id, tq = self.iqd_pmech_imax_umax(
+                        sp, Pmax, i1max, u1max,
+                        with_mtpa, with_tmech)
+                else:
+                    iq, id, tq = self.iqd_imax_umax(
+                        i1max, w1max, u1max,
+                        T, with_mtpv=False,
+                        with_tmech=with_tmech)
+                break
+            except ValueError:
+                sp -= 5e-2*speedmax
+        speedmax = sp
         i1 = betai1(iq, id)[1]
         if (abs(i1max) >= i1
             and round(u1max, 1) >= round(np.linalg.norm(
@@ -843,7 +891,7 @@ class PmRelMachine(object):
     def characteristics(self, T, n, u1max, nsamples=60,
                         with_mtpv=True, with_mtpa=True,
                         with_pmconst=True, with_tmech=True,
-                        with_torque_corr=False):
+                        with_torque_corr=False, **kwargs):
         """calculate torque speed characteristics.
         return dict with list values of
         id, iq, n, T, ud, uq, u1, i1,
@@ -863,6 +911,9 @@ class PmRelMachine(object):
         r = dict(id=[], iq=[], uq=[], ud=[], u1=[], i1=[], T=[],
                  beta=[], gamma=[], phi=[], cosphi=[], pmech=[], n=[])
 
+        if kwargs.get('i1max', 0):
+            w1type, T = self.w1_imax_umax(kwargs['i1max'], u1max)
+
         if np.isscalar(T):
             tmax = self.torquemax(self.i1range[1])
             tmin = 0
@@ -923,6 +974,9 @@ class PmRelMachine(object):
             if speedrange[-1] < speedrange[-2]:
                 speedrange = speedrange[:-1]
             logger.info("Speedrange T=%g Nm %s", Tf, speedrange)
+            if speedrange[-1] < nmax:
+                logger.warning("adjusted nmax %f -> %f", nmax, speedrange[-1])
+
             n3 = speedrange[-1]
             nstab = [int(nsamples*(x1-x2)/n3)
                      for x1, x2 in zip(speedrange[1:],
@@ -1135,7 +1189,12 @@ class PmRelMachineLdq(PmRelMachine):
         if np.any(beta[beta > np.pi]):
             beta[beta > np.pi] = beta - 2*np.pi
 
-        self.io = iqd((np.min(beta)+max(beta))/2, np.max(i1)/2)
+        self.betarange = min(beta), max(beta)
+        if min(beta) < -np.pi/2 and max(beta) > -np.pi/2:
+            self.io = iqd(-np.pi/4, np.max(i1)/2)
+        else:
+            self.io = iqd((np.min(beta)+max(beta))/2, np.max(i1)/2)
+
         kx = ky = 3
         if len(i1) < 4:
             ky = len(i1)-1

femagtools/machine/sm.py

@@ -46,6 +46,7 @@ def parident(workdir, engine, machine,
         speed: rotor speed in 1/s (default 160/p)
         i1_max: maximum current in A rms (default approx 3*i1nom)
         """
+        cmd = kwargs.get('cmd', None)
         da1 = machine['outer_diam']
         Q1 = machine['stator']['num_slots']
         if 'statorRotor3' in machine['stator']:
@@ -59,7 +60,7 @@ def parident(workdir, engine, machine,
         N = machine[wdgk]['num_wires']
         i1_max = round(0.28*np.pi*hs*(da1+hs)/Q1/N*Jmax*1e5)*10 * \
             machine[wdgk].get('num_par_wdgs', 1)
-
+        
         ifnom = machine['rotor']['ifnom']
         exc_logspace = True
         if exc_logspace:
@@ -78,7 +79,7 @@ def parident(workdir, engine, machine,
 
         parvar = parstudy.List(
             workdir,  condMat=condMat,
-            magnetizingCurves=magnetizingCurves)
+            magnetizingCurves=magnetizingCurves, cmd=cmd)
 
         simulation = dict(
                 calculationMode=kwargs.get('calculationMode',
@@ -240,6 +241,7 @@ class SynchronousMachine(object):
         self.kth1 = KTH
         self.kth2 = KTH
         self.skin_resistance = [None, None]
+        self.kpmag = 1
         # here you can set user defined functions for calculating the skin-resistance,
         # according to the current frequency w. First function in list is for stator, second for rotor.
         # If None, the femagtools intern default implementation is used.