femagtools 1.8.13__py3-none-any.whl → 1.8.15__py3-none-any.whl

femagtools/machine/im.py

@@ -119,7 +119,6 @@ class InductionMachine(Component):
         if 'u1type' in parameters:
             self.u1ref = self.u1type
         if hasattr(self, 'f1ref'):
-            #self.wref = 2*np.pi*self.f1ref[0]
             self.wref = 2*np.pi*self.f1ref
             if hasattr(self, 'u1ref'):
                 self.psiref = self.u1ref/self.wref
@@ -522,9 +521,10 @@ class InductionMachine(Component):
             wmrange = sorted([0, wmType, wmPullout, wmMax])
         elif wmMax < wmType:
             wmrange = sorted([0, wmMax])
+        elif wmType<0 or wmPullout<0 or wmMax<0:
+            wmrange = sorted([1, abs(min(wmMax,wmType, wmPullout)), abs(max(wmMax,wmType, wmPullout))])
         else:
             wmrange = sorted([0, wmType, wmMax])
-
         logger.info("Speed range %s", wmrange)
         wmlin = []
         dw = 0
@@ -604,6 +604,7 @@ class InductionMachine(Component):
                 r['eta'] += (pmech[i:]/(p1[i:])).tolist()
             else:
                 r['eta'] += (p1[i:]/pmech[i:]).tolist()
+
         return r
 
 
@@ -660,7 +661,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
                                       num_steps)]
     else:
         i1tab = np.linspace(i1min, i1max, num_steps).tolist()
-        
+
     m = copy.deepcopy(machine)
     Q2 = m['rotor']['num_slots']
     noloadsim = dict(
@@ -668,7 +669,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
         curvec=i1tab,
         num_par_wdgs=machine[wdgk].get('num_par_wdgs', 1),
         Q2=Q2)
-    
+
     da1 = m['bore_diam']
     ag = m['airgap']
     # do not create airgap nodechains automatically
@@ -679,11 +680,11 @@ def parident(workdir, engine, f1, u1, wdgcon,
         m[wdgk].pop('resistance')
     except KeyError:
         pass
-
+    
     parstudy = femagtools.parstudy.ParameterStudy(
         workdir, condMat=condMat,
         magnetizingCurves=magnetizingCurves, cmd=cmd)
-
+    
     builder = femagtools.fsl.Builder(kwargs.get('templatedirs', []))
     model = femagtools.model.MachineModel(m)
     # modelfiles = parstudy.setup_model(builder, model)
@@ -722,7 +723,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
             rotorbar['rotor'][k]['num_slots_gen'] = 1
             rotorbar['rotor'][k]['zeroangle'] = 90-180/Q2
             break
-      
+
     loadsim = dict(  # not used
         calculationMode="asyn_motor",
         bar_len=bar_len,
@@ -740,7 +741,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
     task = job.add_task(_eval_noloadrot(pmod), extra_result_files)
     logger.debug("Task %s noload workdir %s result files %s",
                  task.id, task.directory, task.extra_result_files)
-    # create model 
+    # create model
     for mc in parstudy.femag.copy_magnetizing_curves(
             model,
             dir=task.directory):
@@ -754,11 +755,10 @@ def parident(workdir, engine, f1, u1, wdgcon,
 
     # ec simulation
     barmodel = femagtools.model.MachineModel(rotorbar)
-    barmodel_new = barmodel
-    barmodel_new['stator']['ecSimulation']=1
     extra_result_files = ['bar.dat']
     r = (da1-ag)/2
-    task = job.add_task(_eval_ecsim())
+    #task = job.add_task(_eval_ecsim())
+    task = job.add_task(_eval_ecsim(), extra_result_files)
     logger.debug("Task %s rotobar workdir %s result files %s",
                  task.id, task.directory, task.extra_result_files)
     task.set_stateofproblem('mag_dynamic')
@@ -769,7 +769,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
         task.add_file(mc)
     task.add_file(
         'femag.fsl',
-        builder.create_model(barmodel_new,
+        builder.create_model(barmodel,
                              condMat=parstudy.femag.condMat) +
         builder.create_analysis(ecsim) +
         ['save_model("close")'])
@@ -795,10 +795,9 @@ def parident(workdir, engine, f1, u1, wdgcon,
     logger.info('Started %s', status)
     status = engine.join()
     tend = time.time()
-    logger.info("Elapsed time %d s Status %s",
+    logger.info("Elapssed time %d s Status %s",
                 (tend-tstart), status)
     if any([x != 'C' for x in status]):
-        logger.error("AC simulation failed with statuses: %s", status)
         raise ValueError("AC simulation failed")
     # collect results
     results = [t.get_results() for t in job.tasks]
@@ -821,16 +820,17 @@ def parident(workdir, engine, f1, u1, wdgcon,
     u1ref = u1ph
     psiref = u1ref/w1
 
-    # def inoload(x, iml, ims, mexp):
-    #    """return noload current"""
-    #    return iml*x/psiref + ims*(x/psiref)**mexp
-    # fitp, cov = so.curve_fit(inoload, psihtab, i10tab, (1, 1, 1))
-    # iml, ims, mexp = fitp
-    # logger.info("iml, ims, mexp %g, %g, %g",
-    #            iml, ims, mexp)
-    # i1tab.insert(0, 0)
-    # psi1_0.insert(0, 0)
-    # i1_0.insert(0, 0)
+  # def inoload(x, iml, ims, mexp):
+  #    """return noload current"""
+  #    return iml*x/psiref + ims*(x/psiref)**mexp
+  # fitp, cov = so.curve_fit(inoload, psihtab, i10tab, (1, 1, 1))
+  # iml, ims, mexp = fitp
+  # logger.info("iml, ims, mexp %g, %g, %g",
+  #            iml, ims, mexp)
+  # i1tab.insert(0, 0)
+  # psi1_0.insert(0, 0)
+  # i1_0.insert(0, 0)
+
     logger.info("psi1_0 %s", np.mean(psi1_0, axis=1))
     logger.info("psih %s", psih)
     logger.debug("psi1_0-psih %s", np.mean(psi1_0, axis=1)-psih)
@@ -851,7 +851,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
             hs = machine['stator'][slotmodel].get('slot_height',
                                                   0.33*(machine['outer_diam']-da1))
         n = machine[wdgk]['num_wires']
-        if 'dia_wire' in machine[wdgk]:
+        if 'dia_wire' in machine[wdgk] and machine[wdgk].get('dia_wire', 1e-3) !=0:
             aw = np.pi*machine[wdgk].get('dia_wire', 1e-3)**2/4
         else:  # wire diameter from slot area
             aw = 0.75 * \
@@ -878,6 +878,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
     #                             kind='quadratic')(imref))
     psihref = float(log_interp1d(i1tab, psih)(imref))
     psi1ref = float(psi1(imref))
+  
 
     lh = psihref/imref
     L1 = psi1ref/imref
@@ -908,8 +909,37 @@ def parident(workdir, engine, f1, u1, wdgcon,
     # r2 = results[1]['r2']
     # ls2 = results[1]['ls2']
     pfe = results[2]['pfe1'][0]
+
+    end_ring_section = machine['rotor']['Aring']
+    bore_diam = machine['bore_diam']
+    for key, value in machine['rotor'].items():
+        if isinstance(value, dict) and 'slot_height' in value:
+            slot_height_rotor = value['slot_height']
+            break
+    if slot_height_rotor is not None:
+        rayon = (bore_diam / 2) - slot_height_rotor/2
+        end_ring_length = 2 * np.pi * rayon
+    else:
+        end_ring_length = 0
+
+    end_ring_volume = end_ring_section*end_ring_length
+
+    for material_info in condMat:
+        if material_info.get('name') == machine.get('rotor', {}).get('material'):
+            spmaweight_rotor = material_info.get('spmaweight')
+            break
+        else:
+            spmaweight_rotor = 0
+    end_ring_mass = end_ring_volume * spmaweight_rotor*1e3
+
     rotor_mass = sum([results[2].get('conweight', 0),
                       results[2].get('lamweight', 0)])
+    logger.info('Conductor mass in rotor = %s',results[2].get('conweight', 0))
+    logger.info('Lamination mass in rotor = %s',results[2].get('lamweight', 0))
+    logger.info('Rotor mass without end-ring = %s',rotor_mass)
+    rotor_mass += 2*end_ring_mass
+    logger.info('One end-ring mass = %s',end_ring_mass)
+    logger.info('Total rotor mass = %s',rotor_mass)
 
     n = machine[wdgk]['num_wires']
     g = loadsim['num_par_wdgs']
@@ -977,12 +1007,13 @@ class _eval_noloadrot():
         i0 = np.linalg.norm(
             femagtools.machine.T(0).dot(ire.T),
             axis=0)/np.sqrt(2)
+        
 
         psi0 = np.array([np.linalg.norm(
             femagtools.machine.T(0).dot(psire[:, k, :].T),
             axis=0)/np.sqrt(2)
             for k in range(ncurs)])
-
+        
         # matrix (i x j x k) of curr, rotor pos, angle
         Bamp = [[femagtools.airgap.fft(bags[:, 0], b, self.pmod)['Bamp']
                  for b in bags.T[1:]]

femagtools/machine/pm.py

@@ -92,7 +92,8 @@ class PmRelMachine(object):
         self.io = (1, -1)
         self.fo = 50.0
         self.tcu1 = 20
-        self.tmag = 20
+        # for information purpose only
+        self.tmag = kwargs.get('tmag', 20)
         self.zeta1 = 0.2
         self.gam = 0.7
         self.kh = 2

femagtools/machine/sizing.py

@@ -381,7 +381,7 @@ def get_stator_dimensions(par, slots=[]):
         Da2 = Da1-2*airgap
     r = dict(
         lfe=round(lfe, 3),
-        Dy1=round(Dy1, 3), 
+        Dy1=round(Dy1, 3),
         Da1=round(Da1, 4),
         Da2=round(Da2, 4),
         ans=round(ans, 6),
@@ -546,9 +546,10 @@ def get_interior_magnet_dimensions(I1, N, kw, psi1, lfe, Da2, par):
             iron_shape=Da2/2))
 
 
-def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='rotorKs2'):
+def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='statorRotor3'):
     r = dict()
     r['Da2'] = Da2
+    r['rotorfilfact']=0.95
     if 'Q2' not in par:
         r['num_slots'] = _rotor_slots(par['Q1'], par['p'])[0]
     else:
@@ -568,15 +569,42 @@ def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='rotorKs2'):
     taup = np.pi * Da2/(2*par['p'])
     hyr = psi1/2/lfe*par['By']
     r['Dy2'] = round(Da2 - 2*hr - 2*hyr, 4)
-    logger.info("Dy2 %f Da2 %f hys %f hr %f",
-                r['Dy2']*1e3, Da2*1e3, hyr*1e3, hr*1e3)
     slotwidth = 1e-3
     Q2 = r['num_slots']
     r1 = wr/2-slotwidth
     r2 = (Da2/2-hr-hs1)*np.tan(alfar)
+
     logger.info("Dy2 %f Da2 %f hys %f hr %f",
                 r['Dy2']*1e3, Da2*1e3, hyr*1e3, hr*1e3)
-    if rtype == 'statorRotor3':
+
+    # End-ring calculation
+    Ir_total_estimated = A * np.pi * Da2 / (2 * par['p'])
+    Ibar_eff = Ir_total_estimated / r['num_slots']
+
+    if r['num_slots'] > 0:
+        sin_term = np.sin(np.pi / r['num_slots'])
+        if sin_term != 0:
+             Iring_max_eff = Ibar_eff / (2 * sin_term)
+        else:
+             Iring_max_eff = 0
+    else:
+        Iring_max_eff = 0
+    if 'Jring' not in par:
+        par['Jring'] = par.get('J', 4e6)
+
+    Jring = par['Jring']
+
+    if 'kfilling_ring' not in par:
+        par['kfilling_ring'] = 1.0
+
+    kfilling_ring = par['kfilling_ring']
+
+    if Jring * kfilling_ring > 0:
+        Aring = Iring_max_eff / (Jring * kfilling_ring)
+    else:
+        Aring = 0
+
+    """if rtype == 'statorRotor3':
         r['statorRotor3'] = dict(
             slot_width=slotwidth,
             tooth_width=round(wt, 4),
@@ -589,6 +617,18 @@ def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='rotorKs2'):
             wedge_width1=0,
             wedge_width2=0,
             middle_line=0)
+        r['statorRotor3'] = dict(
+            slot_width=1e-3,
+            tooth_width=0,
+            slot_height=0.0157,
+            slot_top_sh=0,
+            slot_h1=0.5e-3,
+            slot_h2=2.2e-3,
+            slot_r1=2.2e-3,
+            slot_r2=1e-3,
+            wedge_width1=1e-3,
+            wedge_width2=0,
+            middle_line=0)
     elif rtype == 'rotorAsyn':
         r['rotorAsyn'] = dict(
             slot_bs2=0.1e-3,
@@ -612,8 +652,52 @@ def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='rotorKs2'):
             slot_h2=0,
             slot_r1=1e-3,  # r1,
             slot_r2=1e-3,  # r2,
+            middle_line=0)"""
+        
+    all_rotor_types = {}
+
+    all_rotor_types['statorRotor3'] = dict(
+            slot_width=slotwidth,
+            tooth_width=round(wt, 4),
+            slot_height=round(hr+r2, 4),
+            slot_top_sh=1.0,
+            slot_h1=round(hs1, 4),
+            slot_h2=round(hs1+r1, 4),
+            slot_r1=round(r1, 4),
+            slot_r2=round(r2),
+            wedge_width1=0,
+            wedge_width2=0,
             middle_line=0)
 
+    all_rotor_types['rotorAsyn'] = dict(
+        slot_bs2=0.1e-3,
+        slot_hs2=0.5e-3,
+        slot_b32=0.0,
+        slot_h32=0.0,
+        slot_b42=0.0,
+        slot_h42=0.0,
+        slot_b52=round(wr, 4),
+        slot_b62=3e-3,
+        slot_h52=2.5e-3,
+        slot_h62=round(hr, 4),
+        slot_h72=2e-3
+    )
+
+    all_rotor_types['rotorKs2'] = dict(
+        slot_angle=round(2 * alfar * 180 / np.pi, 2),
+        slot_height=round(hr + r1 + r2, 4),
+        slot_topwidth=round(wr, 4),
+        slot_width=slotwidth,
+        slot_h1=hs1,
+        slot_h2=0,
+        slot_r1=1e-3,  # r1,
+        slot_r2=1e-3,   # r2,
+        middle_line=0
+    )
+
+
+    r.update(all_rotor_types)
+    r['Aring'] = Aring
     return r
 
 
@@ -949,7 +1033,7 @@ def im(pnom: float, speed: float, p: int, **kwargs) -> dict:
         slots = []
     r = get_stator_dimensions(par, slots=slots)
     # rotor parameters
-    rtype = kwargs.get('rtype', 'rotorKs2')
+    rtype = kwargs.get('rtype', 'statorRotor3')
     r['rotor'] = get_im_rotor_dimensions(
         par['cos_phi']*r['A'], r['Da2'], r['psi1'], r['lfe'],
         par, rtype=rtype)
@@ -987,12 +1071,13 @@ def eesm(pnom: float, speed: float, p: int, **kwargs) -> dict:
     r['name'] = f"EESM-{r['poles']}"
     return r
 
+
 if __name__ == "__main__":
     # sizing example with SPM
     pnom = 10e3  # shaft power in W
     speed = 4400/60  # speed in 1/s
     p = 4  # number of pole pairs
-    udc = 600  # DC voltage in V 
+    udc = 600  # DC voltage in V
 
     r = spm(pnom, speed, p, udc=udc)
 

femagtools/machine/sm.py

@@ -7,7 +7,7 @@ import pathlib
 import numpy as np
 import scipy.optimize as so
 import scipy.interpolate as ip
-from .utils import skin_resistance, wdg_resistance, betai1, iqd, KTH, create_wdg
+from .utils import skin_resistance, wdg_resistance, betai1, iqd, KTH, create_wdg, loss_models
 from .. import parstudy, windings
 import femagtools.bch
 
@@ -50,6 +50,7 @@ def parident(workdir, engine, machine,
         beta_max: maximal current angle (default 0°)
         num_move_steps: number of move steps
         cmd: femag command (default None, platform executable)
+        feloss: jordan, steinmetz, modified steinmetz, bertotti
         """
     cmd = kwargs.get('cmd', None)
 
@@ -125,6 +126,9 @@ def parident(workdir, engine, machine,
         period_frac=kwargs.get('period_frac', 6),
         speed=kwargs.get('speed', 50))
 
+    if kwargs.get("feloss", 0): 
+        simulation["feloss"] = kwargs["feloss"]
+        machine["calc_fe_loss"] = loss_models[kwargs["feloss"].lower()]
     ###self.cleanup()  # remove previously created files in workdir
     results = parvar(parvardef, machine, simulation, engine)
     b = results['f'][-1]

femagtools/machine/utils.py

@@ -8,9 +8,16 @@ import numpy.linalg as la
 import scipy.interpolate as ip
 import logging
 from .. import parstudy, windings
+from ..model import MachineModel
 
 logger = logging.getLogger(__name__)
 
+loss_models = {
+    "modified steinmetz": 10,
+    "bertotti": 11,
+    "jordan": 1,
+    "steinmetz": 1
+}
 
 def K(d):
     """space phasor transformation matrix
@@ -369,6 +376,7 @@ def dqparident(workdir, engine, temp, machine,
     period_frac: (int) fraction of rotating angle (default 6)
     dqtype: (str) type of identification: 'ldq' (default), 'psidq'
     cmd: femag executable
+    feloss: jordan, steinmetz, modified steinmetz, bertotti
     """
     import pathlib
 
@@ -390,21 +398,25 @@ def dqparident(workdir, engine, temp, machine,
     else:
         fcu = 0.42
 
-    try: # calc basic dimensions if not fsl or dxf model
-        from ..model import MachineModel
+    try:
         wdg = create_wdg(machine)
-        Q1 = wdg.Q
-        model = MachineModel(machine)
-        Jmax = 30e6  # max current density in A/m2
-        Acu = fcu*model.slot_area()  # approx. copper area of one slot
-        i1_max = round(g*Acu/wdg.l/N*Jmax/10)*10
     except KeyError:
-        if kwargs.get('i1_max', 0) == 0:
-            raise ValueError('i1_max missing')
+        pass
+    model = MachineModel(machine)
+    if kwargs.get('i1_max', 0):
         i1_max = kwargs['i1_max']
+    else:
+        try: # calc basic dimensions if not fsl or dxf model
+            Jmax = 30e6  # max current density in A/m2
+            Acu = fcu*model.slot_area()  # approx. copper area of one slot
+            i1_max = round(g*Acu/wdg.l/N*Jmax/10)*10
+        except KeyError:
+            raise ValueError('i1_max missing')
 
     # winding resistance
     try:
+        da1 = machine['bore_diam']
+        hs = model.slot_height()
         if 'wire_gauge' in machine[wdgk]:
             aw = machine[wdgk]['wire_gauge']
         elif 'dia_wire' in machine[wdgk]:
@@ -412,10 +424,10 @@ def dqparident(workdir, engine, temp, machine,
         elif ('wire_width' in machine[wdgk]) and ('wire_height' in machine[wdgk]):
             aw = machine[wdgk]['wire_width']*machine[wdgk]['wire_height']
         else:  # wire diameter from slot area
-            da1 = machine['bore_diam']
+            Q1 = wdg.Q
             aw = 0.75 * fcu * np.pi*da1*hs/Q1/wdg.l/N
-        r1 = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
-    except (NameError, KeyError):
+        r1 = float(wdg_resistance(wdg, N, g, aw, da1, hs, lfe))
+    except (NameError, KeyError) as ex:
         r1 = 0  # cannot calc winding resistance
 
     n = len(temp)
@@ -483,6 +495,10 @@ def dqparident(workdir, engine, temp, machine,
             speed=kwargs.get('speed', defspeed),
             period_frac=period_frac)
 
+    if kwargs.get("feloss", 0):
+        simulation["feloss"] = kwargs["feloss"]
+        machine["calc_fe_loss"] = loss_models[kwargs["feloss"].lower()]
+
     # TODO: cleanup()  # remove previously created files in workdir
     # start calculation
     results = parvar(parvardef, machine, simulation, engine)
@@ -490,7 +506,6 @@ def dqparident(workdir, engine, temp, machine,
     if 'poles' not in machine:  # dxf model?
         machine['poles'] = 2*results['f'][0]['machine']['p']
         da1 = 2*results['f'][0]['machine']['fc_radius']
-        wdg = create_wdg(machine)
     if 'bore_diam' in machine:
         da1 = machine['bore_diam']
     ls1 = 0
@@ -506,6 +521,14 @@ def dqparident(workdir, engine, temp, machine,
     except KeyError:
         rotor_mass = 0  # need femag classic > rel-9.3.x-48-gca42bbd0
 
+    if rotor_mass == 0:
+        try:
+            nc = parvar.femag.read_nc()
+            rotor_mass = float(sum(nc.get_mass()[1].values()))
+            logger.info("rotor mass from nc-file: %.1f kg", rotor_mass)
+        except StopIteration:
+            logger.warning("Could not read nc-file. Setting rotor_mass = 0!")
+
     dq = []
     if dqtype == 'ldq':
         for i in range(0, len(results['f']), 2):
@@ -585,7 +608,7 @@ def dqparident(workdir, engine, temp, machine,
             # diameter of wires
             aw = fcu*asl/Q1/nlayers/N
             hs = asl/(np.pi*da1/3)
-            dqpars['r1'] = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
+            dqpars['r1'] = float(wdg_resistance(wdg, N, g, aw, da1, hs, lfe))
 
     if 'current_angles' in results['f'][0]:
         dqpars['current_angles'] = results['f'][0]['current_angles']

femagtools/multiproc.py

@@ -235,6 +235,12 @@ class Engine:
         self.pool = None # garbage collector deletes threads
         return status
 
+    def read_nc(self):
+        """return a generator object of nc list"""
+        for t in self.job.tasks:
+            yield t.read_nc()
+        return None
+
     def stopThreads(self):
         """ stop all running treads
         """

femagtools/parstudy.py

@@ -310,7 +310,7 @@ class ParameterStudy(object):
                         set_magnet_properties(model, fea, self.femag.magnets)
                     task.add_file(
                         'femag.fsl',
-                        builder.create_model(model, self.femag.magnets) if not data_model_created else [] +
+                        (builder.create_model(model, self.femag.magnets) if not data_model_created else []) +
                         builder.create_analysis(fea) +
                         ['save_model("close")'],
                         append=data_model_created  # model already created, append fsl

femagtools/plot/wdg.py

@@ -7,6 +7,7 @@
 """
 import numpy as np
 import matplotlib.pyplot as plt
+import logging
 
 
 def currdist(wdg, title='', k='all', phi=0, ax=0):
@@ -81,13 +82,13 @@ def mmf_fft(f, title='', mmfmin=1e-2, ax=0):
         pass
 
 
-def zoneplan(wdg, write_title=True, max_slots=0, ax=0):
+def zoneplan(wdg, write_title=True, ax=0, max_slots=0):
     """plot zone plan of winding wdg"""
     from matplotlib.patches import Rectangle
     upper, lower = wdg.zoneplan()
     Qb = len([n for l in upper for n in l])
     if max_slots:
-        Qb = max_slots
+        Qb = min(max_slots, Qb)
     from femagtools.windings import coil_color
     h = 0.5
     w = 1
@@ -171,7 +172,7 @@ def winding_factors(wdg, n=8, ax=0):
         pass
 
 
-def winding(wdg, ax=0):
+def winding(wdg, ax=0, max_slots=0):
     """plot coils of windings wdg"""
     from matplotlib.patches import Rectangle
     from matplotlib.lines import Line2D
@@ -186,12 +187,16 @@ def winding(wdg, ax=0):
     if ax == 0:
         ax = plt.gca()
     z = wdg.zoneplan()
+    z0 = z[0] if len(z[0]) >= len(z[1]) else z[1]
+    Qb = sum([len(l) for l in z0])
+    if max_slots:
+        Qb = min(max_slots, Qb)
     xoff = 0
     if z[-1]:
         xoff = 0.75
     yd = dslot*wdg.yd
     mh = 2*coil_height/yd
-    slots = sorted([abs(n) for m in z[0] for n in m])
+    slots = sorted([abs(n) for m in z[0] for n in m])[:Qb]
     smax = slots[-1]*dslot
     for n in slots:  # draw slots and lamination
         x = n*dslot
@@ -204,6 +209,15 @@ def winding(wdg, ax=0):
                 backgroundcolor="white",
                 bbox=dict(boxstyle='circle,pad=0', fc="white", lw=0))
 
+    # colors in slots
+    csl = [['']*(Qb+1), ['']*(Qb+1)]
+    for i, layer in enumerate(z):
+        for m, mslots in enumerate(layer):
+            for k in mslots:
+                if abs(k) > Qb:
+                    continue
+                csl[i][abs(k)-1] = coil_color[m]
+
     nl = 2 if z[1] else 1
     line_thickness = [0.6, 1.2]
     for i, layer in enumerate(z):
@@ -213,8 +227,9 @@ def winding(wdg, ax=0):
         d = 1
         for m, mslots in enumerate(layer):
             for k in mslots:
+                if abs(k) > Qb:
+                    continue
                 x = abs(k) * dslot + b
-                kcoil = (abs(k)-1)//wdg.yd
                 xpoints = []
                 ypoints = []
                 if nl == 2:
@@ -224,6 +239,12 @@ def winding(wdg, ax=0):
                         d = 1 if i == 1 else 0
                 else:
                     d = 0 if k > 0 else 1
+                    if abs(k) > 1:
+                        if csl[0][abs(k)-2] == coil_color[m]:
+                            d = 1
+                            csl[0][abs(k)-1] = ''
+                        else:
+                            d = 0
 
                 if direction[d] == 'right':
                     # first layer, positive dir or neg. dir and 2-layers:

femagtools/templates/FE-losses.mako

@@ -15,6 +15,3 @@ m.poison          =      ${model.get('poison', 0.3)}
 m.dampfact        =      ${model.get('dampfact', 0.0)}
 m.thcond          =      ${model.get('thcond', 30.0)}
 m.thcap           =      ${model.get('thcap', 480.0)}
-
- pre_models("FE-Losses-1")
- pre_models("FE-Losses-2")

femagtools/templates/ec-rotorbar.mako

@@ -6,8 +6,7 @@ muer = 1
 rel = 100
 cur = {1, 0}
 sigma1, sigma2 = get_dev_data( "cond_conduct" )
---rotorbar = def_new_bar(xb,yb, "green", "U", cur[1],cur[2], "wi",
-rotorbar = def_new_bar(xcoil,ycoil, "green", "U", cur[1],cur[2], "wi", -- xcoil and ycoil defined in rotor_winding_ks2.mako
+rotorbar = def_new_bar(xb,yb, "green", "U", cur[1],cur[2], "wi",
                        sigma2, muer, rel, "polar", 0, 0)
 Abar = get_sreg_data("area",rotorbar)
 

femagtools/templates/ld_lq_fast.mako

@@ -38,4 +38,4 @@ m.load_ex_cur    =     ${model.get('load_ex_cur',0)}
 run_models("ld_lq_f_cur")
 %else:
 run_models("ld_lq_fast")
-%endif
+%endif

femagtools/templates/mesh-airgap.mako

@@ -19,7 +19,6 @@ if not airgap_created then
     end
     x1, y1 = pr2c(r1, alfa)
     n = math.floor(m.fc_radius*alfa/agndst + 1.5)
-    n = n/10 -- Otherwise stacking mesh error TODO find a better formula
     nc_circle_m(r1, 0, x1, y1, 0.0, 0.0, n)
     if(m.npols_gen == m.num_poles) then
        nc_circle_m(x1, y1, r1, 0, 0.0, 0.0, n)