femagtools 1.7.9__py3-none-any.whl → 1.8.0__py3-none-any.whl

femagtools/mcv.py

@@ -103,6 +103,54 @@ def norm_pfe(B, pfe):
                   for x in Bv[:n]] + [None]*(len(Bv)-n))
     return Bv.tolist(), m
 
+def extrapol(crv, jsat=0, bmax=3):
+    """extends BH curve into saturation range"""
+    curve = copy.deepcopy(crv)
+    dh = curve['hi'][-1]-curve['hi'][-2]
+    db = curve['bi'][-1]-curve['bi'][-2]
+    mue_d = db/dh
+    mue = curve['bi'][-1]/curve['hi'][-1]
+    db = 3e-2*curve['bi'][-1]
+    b2 = 1.5
+
+    curve['muer'] = [b/MUE0/h if h>0 else float('nan')
+                     for b, h in zip(curve['bi'],
+                                     curve['hi'])]
+
+    # extend bh-curve into saturation
+    while mue_d > 1.01*MUE0 and mue > 1.5*MUE0:
+        mue_d = MUE0 + (mue_d-MUE0)/np.sqrt(b2)
+        curve['bi'].append(curve['bi'][-1]+db)
+        curve['hi'].append(curve['hi'][-1]+db/mue_d)
+        curve['muer'].append(curve['bi'][-1]/MUE0/curve['hi'][-1])
+        b2 += 2
+        mue = curve['bi'][-1]/curve['hi'][-1]
+
+    # Fröhlich-Kennelly coefficients
+    if jsat:
+        hx = curve['hi'][-1]
+        bx = curve['bi'][-1]
+        fkb = 1./jsat
+        fka = (hx/(bx - MUE0*hx) - hx/jsat)
+    else:
+        Js1 = curve['bi'][-1] - MUE0*curve['hi'][-1]
+        Js0 = curve['bi'][-2] - MUE0*curve['hi'][-2]
+        fkb = ((curve['hi'][-1]/Js1 - curve['hi'][-2]/Js0)
+               /(curve['hi'][-1] - curve['hi'][-2]))
+        fka = curve['hi'][-1]/Js1 - fkb*curve['hi'][-1]
+    logger.debug("B values %d Fröhlich-Kennelly coeffs: a %f b %f",
+                 len(curve['bi']), fka, fkb)
+    bstep = 0.15
+    bx = np.arange(curve['bi'][-1] + bstep, bmax, bstep)
+    # Fröhlich-Kennelly approximation
+    b = fkb * bx - MUE0*fka - 1
+    a = fkb * bx
+    c = MUE0*fka
+    nuer = (b + np.sqrt(b*b + 4*a*c))/2/a
+    curve['bi'] += bx.tolist()
+    curve['hi'] += (nuer*bx/MUE0).tolist()
+    return curve
+
 
 def recalc_bsin(curve):
     """recalculates B-H curve (static problems) into effective
@@ -159,7 +207,7 @@ def recalc_hsin(curve):
     return ncurve
 
 
-def approx(db2, curve):
+def approx(db2, curve, ctype):
     """return nuer, bi2, a, b approx for curve"""
     nuek0 = (curve['hi'][1] - curve['hi'][0]) / \
             (curve['bi'][1]-curve['bi'][0])
@@ -191,12 +239,22 @@ def approx(db2, curve):
         nuer.append(MUE0*nuek1)
         bi2.append(bk12)
 
-    a.append(1.0)
-    b.append(MUE0*curve['hi'][-1]-curve['bi'][-1])
+    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])
+    else:
+        a.append(1.0)
+        b.append(MUE0*curve['hi'][-1]-curve['bi'][-1])
     return dict(nuer=nuer, a=a, b=b, bi2=bi2)
 
 
 def fe_sat_mag(curve):
+    """returns maximum polarization of all BH curves"""
     fesat = 0
     for c in curve:
         js2 = c['bi'][-1] - MUE0*c['hi'][-1]
@@ -219,7 +277,7 @@ def findNotNone(l):
 
 
 class Mcv(object):
-    def __init__(self):
+    def __init__(self, data={}):
         # default values from file: mcv.par
         self.ACT_VERSION_MC_CURVE = 0
         self.ORIENTED_VERSION_MC_CURVE = 1
@@ -248,7 +306,6 @@ class Mcv(object):
         self.mc1_induction_factor = self.MC1_INDUCTION_FACTOR
         self.mc1_induction_beta_factor = self.MC1_INDUCTION_BETA_FACTOR
         self.mc1_fe_spez_weigth = self.MC1_FE_SPEZ_WEIGTH
-        self.mc1_fe_sat_magnetization = self.MC1_FE_SAT_MAGNETIZATION
 
         self.mc1_title = ''
         self.version_mc_curve = self.ACT_VERSION_MC_CURVE
@@ -274,26 +331,18 @@ class Mcv(object):
 
         self.mc1_energy = [[0]*self.MCURVES_MAX]*self.MC1_NIMAX
 
-    def rtrimValueList(self, vlist):
-        """cut list at first 0"""
-        le = len(vlist)
-        for i in range(le-1, -1, -1):
-            if vlist[i] != 0.:
-                break
-        return list(vlist[:i+1])
-
-    def __getitem__(self, key):
-        if key == 'ctype':  # for compatibility purposes
-            return self.mc1_type
-        return getattr(self, key)
-
-
-class Writer(Mcv):
-    def __init__(self, data=None):
-        Mcv.__init__(self)
         if data:
             self.setData(data)
 
+            self.mc1_curves = len(self.curve)
+            if self.mc1_type == MAGCRV and self.mc1_curves > 1:
+                self.mc1_type = ORIENT_CRV
+            if self.mc1_type in (ORIENT_CRV, ORIENT_PM_CRV):
+                self.version_mc_curve = self.ORIENTED_VERSION_MC_CURVE
+            elif self.mc1_type == DEMCRV_BR:
+                self.version_mc_curve = self.PARAMETER_PM_CURVE
+
+
     def __setattr__(self, key, val):
         try:
             self.__dict__[key] = val
@@ -317,6 +366,24 @@ class Writer(Mcv):
             pass
         return
 
+    def rtrimValueList(self, vlist):
+        """cut list at first 0"""
+        le = len(vlist)
+        for i in range(le-1, -1, -1):
+            if vlist[i] != 0.:
+                break
+        return list(vlist[:i+1])
+
+    def __getitem__(self, key):
+        if key == 'ctype':  # for compatibility purposes
+            return self.mc1_type
+        return getattr(self, key)
+
+
+class Writer(Mcv):
+    def __init__(self, data=None):
+        Mcv.__init__(self, data)
+
     def getBlockLength(self, d):
         if isinstance(d, string_types) or isinstance(d, bytes):
             try:
@@ -374,11 +441,6 @@ class Writer(Mcv):
 
     def _prepare(self, fillfac, recsin):
         """prepare output format (internal use only)"""
-        if self.mc1_type in (ORIENT_CRV, ORIENT_PM_CRV):
-            self.version_mc_curve = self.ORIENTED_VERSION_MC_CURVE
-        elif self.mc1_type == DEMCRV_BR:
-            self.version_mc_curve = self.PARAMETER_PM_CURVE
-
         curve = copy.deepcopy(self.curve)
         if fillfac:
             alpha = fillfac/self.mc1_fillfac
@@ -392,17 +454,17 @@ class Writer(Mcv):
         if fillfac or recsin:
             if hasattr(self, 'mc1_fe_sat_magnetization'):
                 self.mc1_fe_sat_magnetization = fe_sat_mag(curve)
-        logger.info("%s Type: %d Num Curves %d",
+        logger.info("%s Type: %d (%s) Num Curves %d",
                     self.name, self.version_mc_curve,
+                    types[self.mc1_type],
                     len(self.curve))
-        self.mc1_curves = len(self.curve)
         self.mc1_ni = [min(len(c['hi']),
                            len(c['bi']))
                        for c in self.curve if 'hi' in c]
         self.mc1_db2 = [(c['bi'][-1]**2 - c['bi'][0]**2)/n
                         for c, n in zip(curve, self.mc1_mi)]
         for db2, c in zip(self.mc1_db2, curve):
-            c.update(approx(db2, c))
+            c.update(approx(db2, c, self.mc1_type))
         if not hasattr(self, 'mc1_fe_sat_magnetization'):
             self.mc1_fe_sat_magnetization = fe_sat_mag(curve)
         self.mc1_mi = [len(c['a'])
@@ -513,6 +575,7 @@ class Writer(Mcv):
                 self.mc1_cw_factor = cw
                 self.mc1_cw_freq_factor = beta
                 self.mc1_induction_factor = gamma
+
         except AttributeError:
             pass
         self.writeBlock([float(self.mc1_base_frequency),
@@ -528,10 +591,10 @@ class Writer(Mcv):
         if not hasattr(self, 'losses') or not self.losses:
             # new variables: ce factor for bertotti losses
             # b_beta_coeff for modified steinmetz
-            try: 
-                self.writeBlock([float(self.mc1_ce_factor), 
+            try:
+                self.writeBlock([float(self.mc1_ce_factor),
                                  float(self.mc1_induction_beta_factor)])
-            except: 
+            except:
                 pass
             return
 
@@ -599,7 +662,7 @@ class Writer(Mcv):
             logger.info('Losses n freq %d n ind %d', nfreq, nind)
         except Exception as e:
             logger.error("Exception %s", e, exc_info=True)
-        
+
     def writeMcv(self, filename, fillfac=None, recsin=''):
         # windows needs this strip to remove '\r'
         filename = filename.strip()
@@ -612,7 +675,7 @@ class Writer(Mcv):
         else:
             binary = False
             self.fp = open(filename, "wb")
-        logger.info("Write File %s, binary format %d", filename, binary)
+        logger.info("Write File %s, binary format", filename)
 
         self.writeBinaryFile(fillfac, recsin)
         self.fp.close()
@@ -737,8 +800,9 @@ class Reader(Mcv):
             if self.version_mc_curve == self.ORIENTED_VERSION_MC_CURVE or \
                self.version_mc_curve == self.PARAMETER_PM_CURVE:
                 self.mc1_curves = int(line[4])
-        logger.debug("MC file %s Version %s Curves %d",
-                     filename, self.version_mc_curve, self.mc1_curves)
+        logger.info("Read file %s %s Type: %d (%s) Num Curves %d",
+                    filename, self.name, self.version_mc_curve,
+                    types[self.mc1_type], self.mc1_curves)
         if self.mc1_type == DEMCRV_BR:
             self.mc1_angle[self.mc1_curves-1] = self.mc1_remz
 
@@ -873,7 +937,7 @@ class Reader(Mcv):
 
         self.ce = 0
         self.b_beta_coeff = 0
-        try: 
+        try:
             if not self.losses['f'][0]:
                 self.fp.seek(-16, 1)
             res = self.readBlock([float]*2)
@@ -882,30 +946,33 @@ class Reader(Mcv):
             pass
 
     def get_results(self):
+        self.desc = self.mc1_title
+        self.fillfac = self.mc1_fillfac
+        #self.cversion = self.version_mc_curve
         result = {
-            'name': self.name,
-            'desc': self.mc1_title,
-            'cversion': self.version_mc_curve,
-            'ctype': self.mc1_type,
-            'recalc': self.mc1_recalc,
-            'remz': self.mc1_remz,
-            'bsat': self.mc1_bsat,
-            'bref': self.mc1_bref,
-            'fillfac': self.mc1_fillfac,
-            'fo': self.fo,
-            'Bo': self.Bo,
-            'ch': self.ch,
-            'ch_freq': self.ch_freq,
-            'cw': self.cw,
-            'ce': self.ce,
-            'b_beta_coeff': self.b_beta_coeff,
-            'cw_freq': self.cw_freq,
-            'b_coeff': self.b_coeff,
-            'rho': self.rho,
-            'fe_sat_mag': self.fe_sat_mag,
-            'curve': [{k: c[k] for k in ('hi', 'bi')}
-                      for c in self.curve]
-        }
+            k: getattr(self, k) for k in (
+                'name',
+                'desc',
+                'cversion',
+                'ctype',
+                'recalc',
+                'remz',
+                'bsat',
+                'bref',
+                'fillfac',
+                'fo',
+                'Bo',
+                'ch',
+                'ch_freq',
+                'cw',
+                'ce',
+                'b_beta_coeff',
+                'cw_freq',
+                'b_coeff',
+                'rho',
+                'fe_sat_mag') if hasattr(self, k)}
+        result['curve'] = [{k: c[k] for k in ('hi', 'bi')}
+                           for c in self.curve]
         try:
             if self.losses:
                 result['losses'] = self.losses
@@ -1003,69 +1070,6 @@ class MagnetizingCurve(object):
             pass
         return None
 
-    def recalc(self):
-        for m in self.mcv:
-            curve = self.mcv[m]['curve'][0]
-            mi = MC1_MIMAX-2
-            dh = curve['hi'][-1]-curve['hi'][-2]
-            db = curve['bi'][-1]-curve['bi'][-2]
-            dmue_d = db/dh
-            dmue = curve['bi'][-1]/curve['hi'][-1]
-            db = 3e-2*curve['bi'][-1]
-            n3 = 1.5
-
-            curve['muer'] = [b/MUE0/h
-                             for b, h in zip(curve['bi'],
-                                             curve['hi'])]
-
-            # extend bh-curve into saturation
-            while dmue_d > 1.01*MUE0 and dmue > 1.5*MUE0:
-                dmue_d = MUE0 + (dmue_d-MUE0)/np.sqrt(n3)
-                curve['bi'].append(curve['bi'][-1]+db)
-                curve['hi'].append(curve['hi'][-1]+db/dmue_d)
-                curve['muer'].append(curve['bi'][-1]/MUE0/curve['hi'][-1])
-                n3 += 0.2
-                dmue = curve['bi'][-1]/curve['hi'][-1]
-
-            self.mcv[m]['db2'] = (curve['bi'][-1]**2 -
-                                  curve['bi'][0]**2)/(mi-1)
-            nuek0 = (curve['hi'][1] - curve['hi'][0]) / \
-                    (curve['bi'][1]-curve['bi'][0])
-            for j1 in range(len(curve['bi'])):
-                bk02 = curve['bi'][j1]**2
-                if bk02 > 0:
-                    break
-            curve['nuer'] = [MUE0*nuek0]
-            curve['bi2'] = [bk02]
-            curve['a'] = []
-            curve['b'] = []
-
-            bk1 = 0.0
-            while bk1 <= curve['bi'][-1]:
-                bk12 = bk02 + self.mcv[m]['db2']
-                bk1 = np.sqrt(bk12)
-                j = 2
-                while j < len(curve['bi']) and bk1 <= curve['bi'][j]:
-                    j += 1
-                j -= 1
-                bdel = curve['bi'][j] - curve['bi'][j1]
-                c1 = (curve['hi'][j] - curve['hi'][j1])/bdel
-                c2 = curve['hi'][j1] - c1*curve['bi'][j1]
-
-                nuek1 = c1 + c2/bk1
-
-                curve['a'].append(MUE0*(bk12*nuek0 -
-                                        bk02*nuek1)/self.mcv[m]['db2'])
-                curve['b'].append(MUE0*(nuek1 - nuek0)/self.mcv[m]['db2'])
-                nuek0 = nuek1
-                bk02 = bk12
-
-                curve['nuer'].append(MUE0*nuek1)
-                curve['bi2'].append(bk12)
-
-            curve['a'].append(1.0)
-            curve['b'].append(MUE0*curve['hi'][-1]-curve['bi'][-1])
-
     def fix_name(self, name, fillfac=1.0):
         """return os compatible mcv name including fillfac"""
         if not self.find_by_name(name):

femagtools/me.py

@@ -3,8 +3,8 @@ Postprocessing FEMAG-ME results
 """
 __author__ = 'dapu zhang'
 
-import re 
-import numpy as np 
+import re
+import numpy as np
 import matplotlib.pyplot as plt
 import logging
 
@@ -16,33 +16,33 @@ def get_eigenvectors(filelist, psfiles):
     eigenvecs = {}
     eigenfreq = []
     ps_data = []
-    temp = [] 
+    temp = []
     temp_arr = []
     read_fig = False
 
     if len(psfiles) > 0: read_fig = True
     if len(filelist) == 0: return []
-    
-    for k, kk in zip(filelist, range(len(filelist))): 
+
+    for k, kk in zip(filelist, range(len(filelist))):
         # read ps file
         if read_fig: ps_data.append(plt.imread(psfiles[kk]))
         eigenvecs[str(kk)] = {}
-        with open(k, 'r') as f: 
+        with open(k, 'r') as f:
             data = f.read().split('\n')
-        eigenval = float(re.split('\s+', data[0].strip())[2])
+        eigenval = float(re.split(r'\s+', data[0].strip())[2])
         eigenfreq.append(eigenval/2/np.pi)
-        
-        for i in range(len(data[1:-1])): 
-            for j in data[2+i].strip().split(' '): 
+
+        for i in range(len(data[1:-1])):
+            for j in data[2+i].strip().split(' '):
                 if j != '':
                     temp.append(float(j))
 
         temp_arr = np.array(temp).reshape(-1, 5)
         idx_collect = []
         # remove the index, at which the dof equals zero
-        for c in range(temp_arr.shape[0]): 
+        for c in range(temp_arr.shape[0]):
             if np.abs(temp_arr[c, 1]) < 1e-15 and \
-            np.abs(temp_arr[c, 2]) < 1e-15: 
+            np.abs(temp_arr[c, 2]) < 1e-15:
                 idx_collect.append(c)
         # prepare the data from the further calculation
         temp_arr = np.delete(temp_arr, np.array(idx_collect), axis=0)
@@ -52,4 +52,4 @@ def get_eigenvectors(filelist, psfiles):
         # return node position
         if kk == 0: eigenvecs.update({'node_pos': temp_arr[:, 4::]})
 
-    return [ps_data, eigenfreq, eigenvecs] 
+    return [ps_data, eigenfreq, eigenvecs]

femagtools/model.py

@@ -392,7 +392,7 @@ class MachineModel(Model):
                         for k in thkeys_shaft:
                             rotor[k+'_shaft'] = mshaft[k]
                         rotor['spmaweight_shaft'] = rotor['rho_shaft']
-                    
+
                     self.stator['mcvkey_shaft_name'] = mcv
                     names.append((mcv, 1.0))
                 else:
@@ -442,7 +442,7 @@ class MachineModel(Model):
 
     def is_complete(self):
         """check completeness of models"""
-        if self.is_dxffile():
+        if self.is_dxffile() or self.is_svgfile():
             return True
         try:
             self.statortype()
@@ -460,6 +460,12 @@ class MachineModel(Model):
                 return True
         return False
 
+    def is_svgfile(self):
+        if 'svgfile' in self.__dict__:
+            if isinstance(self.svgfile, dict):
+                return True
+        return False
+
     def has_magnet(self):  # either rotor or magnet
         return hasattr(self, 'magnet')
 

femagtools/plot/fieldlines.py

@@ -4,7 +4,7 @@ import matplotlib.pyplot as plt
 import numpy as np
 import matplotlib.lines as mpl
 
-rgbpat = re.compile('rgb\((\d+),(\d+),(\d+)\)')
+rgbpat = re.compile(r'rgb\((\d+),(\d+),(\d+)\)')
 
 def fieldlines(svgfilename, ax=0):
     """plot fieldlines from svg file"""

femagtools/plot/mcv.py

@@ -37,10 +37,12 @@ def mcv_hbj(mcv, log=True, ax=0):
             label = 'Flux Density ({0}°)'.format(mcv.mc1_angle[k])
         if log:
             ax.semilogx(hi, bi, label=label)
+            ax.semilogx(hi, bi, 'k.')
             if ji:
                 ax.semilogx(hi, ji, label='Polarisation')
         else:
             ax.plot(hi, bi, label=label)
+            ax.plot(hi, bi, 'k.')
             if ji:
                 ax.plot(hi, ji, label='Polarisation')
     ax.set_xlabel('H / kA/m')
@@ -59,10 +61,26 @@ def mcv_muer(mcv, ax=0):
     if ax == 0:
         ax = plt.gca()
     ax.plot(bi, ur)
+    ax.plot(bi, ur, 'k.')
     ax.set_xlabel('B / T')
     ax.set_title('rel. Permeability')
     ax.grid()
 
+def mcv_nuer(mcv, ax=0):
+    """plot rel. reluctivity vs. B of mcv dict"""
+    MUE0 = 4e-7*np.pi
+    bi, ur = zip(*[(bx, bx/hx/MUE0)
+                   for bx, hx in zip(mcv['curve'][0]['bi'],
+                                     mcv['curve'][0]['hi']) if not hx == 0])
+    if ax == 0:
+        ax = plt.gca()
+    nuer = 1/np.array(ur)
+    ax.plot(bi, 1/np.array(ur))
+    ax.plot(bi, nuer, 'k.')
+    ax.set_xlabel('B / T')
+    ax.set_title('rel. Reluctivity')
+    ax.grid()
+
 
 def felosses(losses, coeffs, title='', log=True, ax=0):
     """plot iron losses with steinmetz or jordan approximation

femagtools/plot/wdg.py

@@ -153,11 +153,11 @@ def winding_factors(wdg, n=8, ax=0):
                                   wdg.kwd(n),
                                   wdg.kw(n))]).T
     try:
-        markerline1, stemlines1, _ = ax.stem(order-1, kwp,
+        markerline1, stemlines1, _ = ax.stem(order-0.5, kwp,
                                              'C1:', basefmt=" ",
                                              markerfmt='C1.',
                                              label='Pitch')
-        markerline2, stemlines2, _ = ax.stem(order+1, kwd,
+        markerline2, stemlines2, _ = ax.stem(order+0.5, kwd,
                                              'C2:', basefmt=" ",
                                              markerfmt='C2.',
                                              label='Distribution')

femagtools/svgfsl/converter.py

@@ -66,7 +66,7 @@ def main():
 
     res = convert(args.svgfile,  # SVG-Filename
                   part=part,
-                  EESM=EESM,
+                  EESM=args.EESM,
                   view_only=args.view,
                   show_plots=args.show_plots,
                   show_areas=args.show_areas,

femagtools/templates/gen_hairpin_winding.mako

@@ -1,9 +1,13 @@
 -- hairpin winding template
 
-rcoil, phi_coil = c2pd(m.xcoil_1, m.ycoil_1)
-
 slot_div_angle = 360/m.tot_num_slot
 
+if m.xcoil_1 ~= nil and m.ycoil_1 ~= nil then 
+  rcoil, phi_coil = c2pd(m.xcoil_1, m.ycoil_1)
+else
+  rcoil, phi_coil = da1/2 + m.slot_height/2, slot_div_angle/2
+end 
+
 -- delete existing mesh in the slot
 for i = 1, m.num_sl_gen do
     xc, yc = pd2c(rcoil, phi_coil+(i-1)*slot_div_angle)
@@ -12,7 +16,7 @@ end
 -- wire params
 wire_height = ${model['wire']["wire_height"]*1e3}
 wire_width = ${model['wire']["wire_width"]*1e3}
-wire_corner_r = ${model['wire']["corner_radius"]*1e3}
+wire_corner_r = 0.0
 wire_gap = ${model['wire']["wire_separation"]*1e3}
 TH1 = ${model['wire']["wire_th1"]*1e3} -- distance to the bore radius
 nwires = ${model['wire']["num_layers"]}
@@ -128,7 +132,7 @@ for j = 1, m.num_sl_gen do
    end
 end
 
-ndt(agndst)
+ndt(agndst*1.5)
 for j = 1, m.num_sl_gen do
   for i = 1, nwires do
     dx, dy = x0+(wire_gap+wire_height)*(i-1), y0
@@ -142,8 +146,8 @@ create_mesh()
 
 -- create winding
 
-widfile = io.open("wid.fsl", 'r')
-
+--widfile = io.open("wid.fsl", 'r')
+widfile = io.open("wid.txt", 'r')
 nrows = 1
 winding = {}
 
@@ -158,52 +162,39 @@ for i in widfile:lines() do
 end
 
 --[[
-
 winding table
-
-1  slot_go pos_in_slot slot_ret pos_in_slot
-
+key slot layer dir
 ]]--
 dir = 'wi'
 cols = {"green", "yellow", "cyan"}
 wk = 1
 for i = 1, #winding do
-    idx = winding[i][2]
-    idxp = winding[i][3]
-    idy = winding[i][4]
-    idyp = winding[i][5]
-
-   if i == 1 then
-        if idx <= m.num_sl_gen then
-            wkey = def_new_wdg(wire_xy[idx][idxp].x, wire_xy[idx][idxp].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, dir)
-        end
-
-        if math.abs(idy) <= m.num_sl_gen then
-            add_to_wdg (wire_xy[math.abs(idy)][idyp].x, wire_xy[math.abs(idy)][idyp].y, "wsamekey", "wo", "wser")
-        end
-   else
-        if winding[i][1] == winding[i-1][1] and winding[i][1] == wk then
-            if idx <= m.num_sl_gen then
-                add_to_wdg (wire_xy[idx][idxp].x, wire_xy[idx][idxp].y, "wsamekey", dir, "wser")
-            end
-            if math.abs(idy) <= m.num_sl_gen then
-                add_to_wdg (wire_xy[math.abs(idy)][idyp].x, wire_xy[math.abs(idy)][idyp].y, "wsamekey", "wo", "wser")
-            end
-        else
-            if idx <= m.num_sl_gen then
-                wkey = def_new_wdg(wire_xy[idx][idxp].x, wire_xy[idx][idxp].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, dir)
-                wk = wk + 1
-            end
-            if math.abs(idy) <= m.num_sl_gen then
-                if wk == winding[i][1] then
-                  add_to_wdg (wire_xy[math.abs(idy)][idyp].x, wire_xy[math.abs(idy)][idyp].y, "wsamekey", "wo", "wser")
-                else
-                  wkey = def_new_wdg(wire_xy[math.abs(idy)][idyp].x, wire_xy[math.abs(idy)][idyp].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, "wo")
+    windingskey = winding[i][1]
+    slot_nr = winding[i][2]
+    layer = winding[i][3]
+    direction = winding[i][4]
+    if direction < 0 then 
+      dir = 'wo'
+    else
+      dir = 'wi'
+    end 
+    if i == 1 then
+          if slot_nr <= m.num_sl_gen then
+              wkey = def_new_wdg(wire_xy[slot_nr][layer].x, wire_xy[slot_nr][layer].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, dir)
+          end
+
+    else
+          if winding[i][1] == winding[i-1][1] and winding[i][1] == wk then
+              if slot_nr <= m.num_sl_gen then
+                  add_to_wdg (wire_xy[slot_nr][layer].x, wire_xy[slot_nr][layer].y, "wsamekey", dir, "wser")
+              end
+            
+          else
+              if slot_nr <= m.num_sl_gen then
+                  wkey = def_new_wdg(wire_xy[slot_nr][layer].x, wire_xy[slot_nr][layer].y, cols[winding[i][1]], "Phase"..winding[i][1], 1, 0, 0, dir)
                   wk = wk + 1
-                end
-            end
-        end
+              end
+          end
    end
 end
-
 m.num_par_wdgs = ${model.get('num_par_wdgs', 1)}