femagtools 1.8.3__py3-none-any.whl → 1.8.4__py3-none-any.whl

femagtools/dxfsl/geom.py

@@ -2256,45 +2256,120 @@ class Geometry(object):
             return center[0]
         return None
 
-    def get_center_arcs(self):
+    def is_same_center(self, center_lst, center, rtol, atol):
+        for c in center_lst:
+            if points_are_close(c['center'], center['center'], rtol, atol):
+                radius = center['radius'][0]
+                if not radius in c['radius']:
+                    c['radius'].append(radius)
+                c['count'] = c['count'] + 1
+                return True
+        return False
+
+    def get_center_with_x(self, center_lst, x):
+        c_list = [c for c in center_lst
+                  if np.isclose(c['center'][0], x, rtol=self.rtol, atol=self.atol)]
+        if not c_list:
+            return None
+        cy_list = [(c['center'][1], c) for c in c_list]
+        cy_list.sort()
+        y, c = cy_list[0]
+        return c
+
+    def get_center_with_y(self, center_lst, y):
+        c_list = [c for c in center_lst
+                  if np.isclose(c['center'][1], y, rtol=self.rtol, atol=self.atol)]
+        if not c_list:
+            return None
+        cy_list = [(c['center'][0], c) for c in c_list]
+        cy_list.sort()
+        [logger.info("y=%s, c=%s", y, c) for y, c in cy_list]
+        y, c = cy_list[0]
+        return c
+
+    def get_center_arcs(self, mm):
         logger.debug("begin of get_center_arcs")
         center_list = []
+        x_min, x_max, y_min, y_max = mm
+
+        def center_is_inside(c):
+            tol = 0.1
+            x, y = c
+            if x-tol > x_min and \
+               x+tol < x_max and \
+               y-tol > y_min and \
+               y+tol < y_max:
+                return True
+            return False
+
         circles = [e for e in self.elements() if is_Circle(e)]
         logger.debug(" -- %s Circles", len(circles))
 
         for e in circles:
             center = (round(e.center[0], 3), round(e.center[1], 3))
-            radius = round(e.radius, 1)
-            center_list.append(([1], center, [radius]))
+            entry = {'center': center,
+                     'radius': [round(e.radius, 1)],
+                     'phi': e.get_angle_of_arc(),
+                     'dist': e.length(),
+                     'inside': center_is_inside(center),
+                     'count': 1}
+            center_list.append(entry)
 
         arcs = [e for e in self.elements() if is_Arc(e)]
         logger.debug(" -- %s Arcs", len(arcs))
 
         for e in arcs:
             center = (round(e.center[0], 3), round(e.center[1], 3))
-            radius = round(e.radius, 1)
-            c = self.get_same_center(center_list, center, self.rtol, self.atol)
-            if c is None:
-                center_list.append(([1], center, [radius]))
-            else:
-                c[0][0] += 1
-                if radius not in c[2]:
-                    c[2].append(radius)
+            entry = {'center': center,
+                     'radius': [round(e.radius, 1)],
+                     'phi': e.get_angle_of_arc(),
+                     'dist': e.length(),
+                     'inside': center_is_inside(center),
+                     'count': 1}
+            if not self.is_same_center(center_list, entry, self.rtol, self.atol):
+                center_list.append(entry)
 
         center = None
-        arc_list = [[len(c[2]), c[0][0], c[1]] for c in center_list]
+        arc_list = [[c['count'], len(c['radius']), c['phi'], n, c]
+                    for n, c in enumerate(center_list)]
         arc_list.sort(reverse=True)
 
-        if arc_list:
-            c1 = arc_list[0]
-            center = c1[2]
-            if len(arc_list) > 1:
-                c2 = arc_list[1]
-                if not c1[0] > c2[0]:
-                    center = None
+        logger.debug("x min/max = %s/%s", x_min, x_max)
+        logger.debug("y min/max = %s/%s", y_min, y_max)
 
-        logger.debug("end of get_center_arcs: -> %s", center)
-        return center
+        [logger.debug("Arc %s", arc) for arc in arc_list]
+        if not arc_list:
+            logger.debug("end of get_center_arcs: no arcs")
+            return None
+
+        cnt, cr1, p, n, c1 = arc_list[0]
+        logger.debug("First Entry: %s", c1)
+        center = c1['center']
+        if len(arc_list) > 1:
+            cnt, cr2, p, n, c2 = arc_list[1]
+            logger.debug("Second Entry: %s", c2)
+            if not cr1 > cr2:
+                center = None
+
+        if center:
+            logger.debug("end of get_center_arcs: -> %s", center)
+            return center
+
+        c_entry = self.get_center_with_x(center_list, x_min)
+        if c_entry:
+            center = c_entry['center']
+            if center[1] < y_min:
+                logger.debug("end of get_center_arcs: x -> %s", center)
+                return center
+        c_entry = self.get_center_with_y(center_list, y_min)
+        if c_entry:
+            center = c_entry['center']
+            if center[0] < x_min:
+                logger.debug("end of get_center_arcs: y -> %s", center)
+                return center
+
+        logger.debug("end of get_center_arcs: no center found")
+        return None
 
     def get_center_dim(self, mm):
         return (round(mm[0], 4), round(mm[2], 4))
@@ -2305,7 +2380,9 @@ class Geometry(object):
             return None
 
         center = None
-        center_arcs = self.get_center_arcs()
+        # Zuerst suchen wir anhand der Circle- und Arc-Segmente nach einem
+        # möglichen Center-Punkt.
+        center_arcs = self.get_center_arcs(mm)
 
         if center_arcs:
             center = center_arcs
@@ -3259,7 +3336,7 @@ class Geometry(object):
             max_size, max_w = windings_surface[0]
             for sz, w in windings_surface[1:]:
                 logger.debug("winding size = %s", sz)
-                if sz / max_size < 0.80:
+                if sz / max_size < 0.70:
                     w.set_type(AREA.TYPE_AIR)
                     if sz / max_size < 0.2:
                         windings_found -= 1

femagtools/dxfsl/machine.py

@@ -135,6 +135,16 @@ class Machine(object):
         self.geom.is_outer = True
         self.geom.is_inner = False
 
+    def set_attributes(self,
+                       kind="",
+                       inner=False,
+                       outer=False):
+        self.set_kind(kind)
+        if inner:
+            self.set_inner()
+        if outer:
+            self.set_outer()
+
     def clear_cut_lines(self):
         self.geom.clear_cut_lines()
         if self.mirror_geom is not None:
@@ -635,9 +645,13 @@ class Machine(object):
         parts = symmetry.find_symmetry()  # temp solution
         logger.debug(">>> Symmetry parts = %s <<<", parts)
 
-        if parts > 1:
-            found = True
-        else:
+        if parts == 1:
+            # no slices, but ok
+            return False
+
+        found = (parts > 1)
+
+        if not found:
             found = self.geom.find_symmetry(self.radius,
                                             self.startangle,
                                             self.endangle,
@@ -833,11 +847,11 @@ class Machine(object):
             if dist_start > dist_end:
                 machine.mirror_all_areas(self.startangle)
                 machine.rotate_to(angle)
-                machine.geom.create_list_of_areas(delete=True)
                 machine.startangle -= angle
             else:
                 machine.mirror_all_areas(self.endangle)
                 machine.endangle += angle
+            machine.geom.create_list_of_areas(delete=True)
             machine.set_alfa_and_corners()
             machine.part = machine.part_of_circle()
             machine.geom.set_subregion_parameters(self.startangle,
@@ -907,23 +921,25 @@ class Machine(object):
                                             first_thirdangle,
                                             second_thirdangle)
         machine_mirror_1.clear_cut_lines()
-
         machine_mirror_1.repair_hull()
         machine_mirror_1.set_alfa_and_corners()
+        if machine_mirror_1.geom.number_of_edges() < 2:  # very bad
+            logger.debug("end get_third_symmetry_mirror: no remaining elements")
+            return None
         if not machine_mirror_1.check_symmetry_graph(0.001, 0.05):
             logger.debug("end get_third_symmetry_mirror: no mirror first third")
             return None
 
         if plt:
             plt.render_elements(machine_mirror_1.geom, Shape,
-                                title="Part",
+                                title="Part 1",
                                 show=True,
                                 with_corners=False,
                                 with_nodes=False,
                                 neighbors=True)
 
             plt.render_elements(machine_mirror_1.mirror_geom, Shape,
-                                title="Counterpart",
+                                title="Counterpart 1",
                                 show=True,
                                 with_corners=False,
                                 with_nodes=False,
@@ -935,10 +951,28 @@ class Machine(object):
         machine_mirror_2.clear_cut_lines()
         machine_mirror_2.repair_hull()
         machine_mirror_2.set_alfa_and_corners()
+        if machine_mirror_2.geom.number_of_edges() < 2:  # very bad
+            logger.debug("end get_third_symmetry_mirror: no remaining elements")
+            return None
         if not machine_mirror_2.check_symmetry_graph(0.001, 0.05):
             logger.debug("end get_third_symmetry_mirror: no mirror second third")
             return None
 
+        if plt:
+            plt.render_elements(machine_mirror_2.geom, Shape,
+                                title="Part 2",
+                                show=True,
+                                with_corners=False,
+                                with_nodes=False,
+                                neighbors=True)
+
+            plt.render_elements(machine_mirror_2.mirror_geom, Shape,
+                                title="Counterpart 2",
+                                show=True,
+                                with_corners=False,
+                                with_nodes=False,
+                                neighbors=True)
+
         machine_mirror_1.previous_machine = self
         logger.debug("end get_third_symmetry_mirror: ok")
         return machine_mirror_1
@@ -992,6 +1026,9 @@ class Machine(object):
                                 with_nodes=False,
                                 neighbors=True)
 
+        if machine_mirror.geom.number_of_edges() < 2:  # very bad
+            logger.debug("end get_symmetry_mirror: no remaining elements")
+            return None
         if machine_mirror.check_symmetry_graph(0.001, 0.05):
             machine_mirror.previous_machine = self
             machine_mirror.rotate_to(0.0)

femagtools/dxfsl/shape.py

@@ -467,6 +467,10 @@ class Circle(Shape):
         r0 = np.linalg.norm(self.center)
         return max(abs(r-r0-self.radius), abs(r-r0+self.radius))
 
+    def length(self):
+        """returns length of this circle"""
+        return self.radius*2*np.pi
+
     def overlapping_shape(self, e, rtol=1e-03, atol=1e-03):
         if not (isinstance(e, Arc) or isinstance(e, Circle)):
             # end overlapping_shape: Circle (not Arc or Circle)

femagtools/dxfsl/symmetry.py

@@ -120,7 +120,15 @@ class Symmetry(object):
         areas.sort(reverse=True)
         return areas
 
+    def get_equal_areas(self, areas):
+        return
+
     def build_results(self, areas):
+        logger.debug("begin of build_results with %s areas", len(areas))
+        [logger.debug("#%s: alpha=%s, min=%s, max=%s",
+                      a.get_id(), alpha, a.min_angle, a.max_angle) for
+         alpha, dist, h, mid, a in areas]
+
         a0_alpha, a0_min_dist, a0_height, a0_mid_angle, a0 = areas[0]
         equal_areas = [(a0_mid_angle, a0)]
         check_rslt = []
@@ -164,6 +172,7 @@ class Symmetry(object):
         rslt['area'] = a0
         rslt['areasize'] = areasize
         check_rslt.append((areasize, rslt))
+        logger.debug("end of build_results")
         return check_rslt
 
     def get_winding_symmetry(self, inside=False):
@@ -246,7 +255,6 @@ class Symmetry(object):
 
         check_rslt = self.build_results(areas)
         logger.debug("%s results available", len(check_rslt))
-        [logger.debug("Result: %s", rslt) for rslt in check_rslt]
 
         parts, start_delta = self.get_symmetry_parts(check_rslt)
         if parts < 2:
@@ -665,6 +673,9 @@ class Symmetry(object):
             m1 = m2
             d1 = d2
 
+        if not mid_list:
+            return None
+
         logger.debug("New Mids: %s", mid_list)
         delta = positive_angle(mid_list[0] * 2)
         delta_list = [delta]
@@ -712,6 +723,41 @@ class Symmetry(object):
         logger.debug("end check_first_last_difference => %s", n1 + 1)
         return n1 + 1
 
+    def concatenate_results(self, check_rslt):
+        if len(check_rslt) < 2:
+            return check_rslt
+        #   ----------
+        def get_slices(rslt):
+            if rslt['slices'] is None:
+                return 0
+            if rslt.get('startdelta', 0.0) != 0.0:
+                return 0
+            if rslt.get('halfslice', None) is not None:
+                return 0
+            return rslt['slices']
+        #   ------
+        new_rslt = []
+        size1, n1, rslt1 = check_rslt[0]
+        slices1 = get_slices(rslt1)
+        for size2, n2, rslt2 in check_rslt[1:]:
+            slices2 = get_slices(rslt2)
+            if slices1 > 0 and \
+               slices1 == slices2 and \
+               np.isclose(size1, size2, rtol=1e-01, atol=1e-01) and \
+               (rslt1.get('delta_corr', 0.0) == 0.0 or \
+                rslt2.get('delta_corr', 0.0) == 0.0):
+                # concatenate
+                rslt1['slices'] = None
+                rslt2['delta_corr'] = 0.0
+                rslt2['areas'] = rslt2['areas'] + rslt1['areas']
+                logger.debug("concatenate results(size %s)", size1)
+            else:
+                new_rslt.append((size1, n1, rslt1))
+            slices1, size1, n1, rslt1 = (slices2, size2, n2, rslt2)
+
+        new_rslt.append((size1, n1, rslt1))
+        return new_rslt
+
     def get_symmetry_parts(self, check_rslt):
         max_size = 0
         max_areas = 0
@@ -720,10 +766,11 @@ class Symmetry(object):
         self.delta_angle_corr = None
         unsure_sym = False
 
-        check_rslt = [(size, n, rslt) for n, (size, rslt) in enumerate(check_rslt)]
+        check_rslt = [(size, n, rslt) for n, (size, rslt) in enumerate(check_rslt)
+                      if rslt['slices'] is not None]
         check_rslt.sort(reverse=True)
-        for size, n, rslt in check_rslt:
-            logger.debug("Result: %s, %s", size, rslt)
+        check_rslt = self.concatenate_results(check_rslt)
+        [logger.debug("Result #%s: %s, %s", n, size, rslt) for size, n, rslt in check_rslt]
 
         rtol = 1e-3
         atol = 1e-2
@@ -740,40 +787,46 @@ class Symmetry(object):
         for size, n, rslt in check_rslt:
             areas = rslt['areas']
             slices = rslt['slices']
+            if slices is None:
+                continue
+
             size = rslt['areasize']
             angle_corr = rslt.get('delta_corr', 0.0)
 
             if rslt.get('halfslice', 0) == 1:
                 halfslice.append(rslt)
 
-            if slices is not None:
-                if slices > 0:
-                    max_size = max(max_size, size)
-                    max_areas = max(max_areas, areas)
-                    max_slices = max(max_slices, slices)
-                    missing_middles += rslt.get('missing_middles', [])
-                    area = rslt['area']
-                    if not (np.isclose(area.min_dist,
-                                       self.geom.min_radius,
-                                       rtol=1e-4, atol=1e-3) and \
-                            np.isclose(area.max_dist,
-                                       self.geom.max_radius,
-                                       rtol=1e-4, atol=1e-3)):
-                        if rslt.get('delta_corr', 0.0) == 0.0:
-                            without_angle_corr += areas * size
-                        else:
-                            with_angle_corr += areas * size
+            if slices > 0:
+                max_size = max(max_size, size)
+                max_areas = max(max_areas, areas)
+                max_slices = max(max_slices, slices)
+                missing_middles += rslt.get('missing_middles', [])
+                area = rslt['area']
+                if not (np.isclose(area.min_dist,
+                                   self.geom.min_radius,
+                                   rtol=1e-4, atol=1e-3) and \
+                        np.isclose(area.max_dist,
+                                   self.geom.max_radius,
+                                   rtol=1e-4, atol=1e-3)):
+                    if rslt.get('delta_corr', 0.0) == 0.0:
+                        without_angle_corr += areas * size
                     else:
-                        maybe_angle_korr += areas * size
+                        with_angle_corr += areas * size
+                else:
+                    maybe_angle_korr += areas * size
+
         logger.debug("max size: %s,  max areas: %s", max_size, max_areas)
+        logger.debug("Angle-Corrections: %s Yes,  %s No, %s Maybe",
+                     with_angle_corr,
+                     without_angle_corr,
+                     maybe_angle_korr)
 
-        logger.debug("Angle-Corrections: %s Yes,  %s No",
-                     with_angle_corr, without_angle_corr)
         if np.isclose(with_angle_corr, without_angle_corr):
             with_angle_corr = (maybe_angle_korr > 0)
         else:
             with_angle_corr = (with_angle_corr > without_angle_corr)
 
+        #   -------------------------
         def get_halfslice_counterpart(rslt):
             if rslt.get('halfslice', 0) != 2:
                 return None
@@ -788,7 +841,7 @@ class Symmetry(object):
                    np.isclose(alpha1, alpha2, rtol=rtol, atol=atol):
                     return half
             return None
-
+        #   -----------
         if halfslice:
             logger.debug("%s halfslice [1] found", len(halfslice))
 

femagtools/fsl.py

@@ -556,7 +556,6 @@ class Builder:
         if 'fsl_rotor' in conv:
             self.fsl_rotor = True
             th_props = ['']
-            logger.debug(model['magnet'])
             if hasattr(model, 'magnet'):
                 if model['magnet'].get('thcond', 0):
                     th_props = [f'rotor_density = {model["magnet"]["density"]}',

femagtools/machine/afpm.py

@@ -11,7 +11,7 @@ from .. import model
 from .. import utils
 from .. import windings
 from .. import femag
-from scipy.interpolate import RegularGridInterpolator, interp1d, RectBivariateSpline
+from scipy.interpolate import make_interp_spline, RegularGridInterpolator, RectBivariateSpline
 from scipy.integrate import quad
 import copy
 
@@ -58,7 +58,7 @@ def _integrate(radius, pos, val):
 
 
 def _integrate1d(radius, val):
-    interp = interp1d(radius, val)
+    interp = make_interp_spline(radius, val, k=1)
     def func(x):
         return interp((x))
     return quad(func, radius[0], radius[-1])[0]

femagtools/machine/effloss.py

@@ -166,9 +166,9 @@ def _generate_mesh(n, T, nb, Tb, npoints):
         nmax = max(n)
         tmin, tmax = 0, max(T)
         tnum = npoints[1]
-    tip = ip.interp1d(n, T)
+    tip = ip.make_interp_spline(n, T, k=1)
     if nb and Tb:
-        tbip = ip.interp1d(nb, Tb)
+        tbip = ip.make_interp_spline(nb, Tb, k=1)
     else:
         def tbip(x): return 0
 

femagtools/machine/im.py

@@ -35,6 +35,9 @@ def log_interp1d(x, y, kind='cubic'):
     logy = np.log10(yy)
     lin_interp = ip.interp1d(logx, logy, kind=kind, fill_value="extrapolate")
     def log_interp(zz): return np.power(10.0, lin_interp(np.log10(zz)))
+    # TODO check replace interp1d
+    #lin_interp = ip.make_interp_spline(logx, logy, bc_type='not-a-knot')
+    #def log_interp(zz): return np.power(10.0, lin_interp(np.log10(zz), nu=1))
     return log_interp
 
 
@@ -792,15 +795,10 @@ def parident(workdir, engine, f1, u1, wdgcon,
     tend = time.time()
     logger.info("Elapsed time %d s Status %s",
                 (tend-tstart), status)
+    if any([x != 'C' for x in status]):
+        raise ValueError("AC simulation failed")
     # collect results
-    results = []
-    errors = []
-    for t in job.tasks:
-        if t.status == 'C':
-            results.append(t.get_results())
-        else:
-            logger.warning("Status %s", t.status)
-            results.append({})
+    results = [t.get_results() for t in job.tasks]
 
     i1_0 = results[0]['i1_0'].tolist()
     psi1_0 = results[0]['psi1_0'].tolist()

femagtools/machine/sm.py

@@ -187,7 +187,7 @@ def parident(workdir, engine, machine,
 
     if simulation['calculationMode'] == 'ld_lq_fast':
         dqpars = dict(m=3, p=b['machine']['p'],
-                      r1=r1,
+                      r1=float(r1),
                       r2=machine['rotor'].get('resistance', 1),
                       rotor_mass=rotor_mass, kfric_b=1,
                       ldq=[dict(
@@ -434,7 +434,7 @@ class SynchronousMachine(object):
     def iqd_tmech(self, torque, n, disp=False, maxiter=500):
         """return currents for shaft torque with minimal losses"""
         if torque > 0:
-            startvals = self.bounds[0][1], 0, self.bounds[-1][1]
+            startvals = self.bounds[0][1]/2, 0, self.bounds[-1][1]
         else:
             startvals = -self.bounds[0][1]/2, 0, self.bounds[-1][1]
 

femagtools/mcv.py

@@ -12,7 +12,7 @@ import pathlib
 import struct
 import math
 import numpy as np
-import scipy.interpolate as ip
+from scipy.interpolate import make_interp_spline
 from six import string_types
 import femagtools.losscoeffs as lc
 
@@ -99,7 +99,7 @@ def norm_pfe(B, pfe):
                 b = list(b)
                 b[-1] = Bv[n]
                 n += 1
-        pfunc = ip.interp1d(b, pfe[i], kind='cubic')
+        pfunc = make_interp_spline(b, pfe[i])
         m.append([float(pfunc(x))
                   for x in Bv[:n]] + [None]*(len(Bv)-n))
     return Bv.tolist(), m
@@ -168,8 +168,7 @@ def recalc_bsin(curve):
         if bi[0] > 0:
             bi.insert(0, 0)
             hi.insert(0, 0)
-        bh = ip.interp1d(bi, hi,
-                         kind='cubic', assume_sorted=True)
+        bh = make_interp_spline(bi, hi)
         for bx in c['bi'][2:]:
             bt = bx*np.sin(2*np.pi/4/ndel*x)
             nue = np.sum(bh(bt)/bt)/ndel
@@ -196,8 +195,7 @@ def recalc_hsin(curve):
         if hi[0] > 0:
             hi.insert(0, 0)
             bi.insert(0, 0)
-        hb = ip.interp1d(hi, bi,
-                         kind='cubic', assume_sorted=True)
+        hb = make_interp_spline(hi, bi)
         for hx in c['hi'][2:]:
             ht = hx*np.sin(2*np.pi/4/ndel*x)
             bt = hb(ht)*np.sin(2*np.pi/4/ndel*x)
@@ -243,11 +241,12 @@ def approx(db2, curve, ctype):
     if ctype in (DEMCRV, MAG_AC_CRV):
         dhdbn = 0
         k = len(bi2)-1
-        if curve['bi'][k] - curve['bi'][k-1] > 0:
-            dhdbn = ((curve['hi'][k] - curve['h'][k-1],KK)
-                     /(curve['bi'][k] - curve['bi'][k-1]))
-        a.append(MUE0*dhdbn)
-        b.append(MUE0*curve['hi'][k] - dhdbn*curve['bi'][k])
+        if k < len(curve['bi']):
+            if curve['bi'][k] - curve['bi'][k-1] > 0:
+                dhdbn = ((curve['hi'][k] - curve['h'][k-1])
+                         /(curve['bi'][k] - curve['bi'][k-1]))
+            a.append(MUE0*dhdbn)
+            b.append(MUE0*curve['hi'][k] - dhdbn*curve['bi'][k])
     else:
         a.append(1.0)
         b.append(MUE0*curve['hi'][-1]-curve['bi'][-1])

femagtools/templates/mesh-airgap.mako

@@ -44,10 +44,16 @@ if not airgap_created then
     nc_line(r2, 0.0, x2, y2, 0.0)
 
     if m.tot_num_slot > m.num_sl_gen then
+      if inner_da_end == nil then
+        inner_da_end = inner_da_start
+      end
       x3, y3 = pr2c(inner_da_end, alfa)
       x4, y4 = pr2c(r1, alfa)
       nc_line(x3, y3, x4, y4, 0, 0)
 
+      if outer_da_end == nil then
+        outer_da_end = outer_da_start
+      end
       x3, y3 = pr2c(outer_da_end, alfa)
       x4, y4 = pr2c(r2, alfa)
       nc_line(x3, y3, x4, y4, 0, 0)

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[:-1]) > 0
+        ypos = np.asarray(y[:-1])-np.mean(y[:-1]) > 0
         nypos = ~ypos
         nzc = len(((ypos[:-1] & nypos[1:])
                    | (nypos[:-1] & ypos[1:])).nonzero()[0])

femagtools/windings.py

@@ -179,10 +179,10 @@ class Winding(object):
             nue = n
         else:
             nue = self.kw_order(n)
-        #if q1 == q2:  # integral slot winding
-        #    q = self.Q/2/self.m/self.p
-        #    nuep = nue/self.p
-        #    return np.sin(nuep*np.pi/2/self.m)/q/np.sin(nuep*np.pi/2/self.m/q)
+        if q1 == q2:  # integral slot winding
+            q = self.Q/2/self.m/self.p
+            nuep = nue/self.p
+            return np.sin(nuep*np.pi/2/self.m)/q/np.sin(nuep*np.pi/2/self.m/q)
         k = 2 if self.l == 1 else 1
         a = nue*k*np.pi/self.Q*Yk
         t = self.Q//Qb
@@ -416,6 +416,13 @@ class Winding(object):
              [[d*s for s, d in zip(l, ld)] for l, ld in zip(lower, ldirs)])
         # complete if not  basic winding:
         Qb = self.Q//num_basic_windings(self.Q, self.p, self.l)
+
+        if not np.asarray(upper).size or not np.asarray(lower).size:
+            layers = 1
+        if layers == 1 and z[1]:
+            z = ([[d*s for s, d in zip(l, ld)] for l, ld in zip(lower, ldirs)],
+                 [[d*s for s, d in zip(u, ud)] for u, ud in zip(upper, udirs)])
+
         if max([abs(n) for m in z[0] for n in m]) < Qb:
             return [[k + [-n+Qb//2 if n < 0 else -(n+Qb//2) for n in k]
                      for k in m] for m in z]