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

femagtools/machine/sm.py

@@ -42,8 +42,8 @@ def parident(workdir, engine, machine,
 
         optional arguments:
         num_cur_steps: number of current steps (default 5)
-        num_beta_steps: number of current steps (default 13)
-        num_exc_steps: number of excitation current (default 7)
+        num_beta_steps: number of beta steps (default 13)
+        num_exc_steps: number of excitation current (default 6)
         speed: rotor speed in 1/s (default 160/p)
         i1_max: maximum current in A rms (default approx 3*i1nom)
         beta_min: minimal current angle (default -180°)
@@ -79,9 +79,14 @@ def parident(workdir, engine, machine,
     exc_logspace = True
     ifmin, ifmax = ifnom/4, 1.4*ifnom
     if exc_logspace:
-        excur = np.logspace(np.log(ifmin), np.log(ifmax),
+        """excur = np.logspace(np.log(ifmin), np.log(ifmax),
                             kwargs.get("num_exc_steps", 6),
-                            base=np.exp(1)).tolist()
+                            base=np.exp(1)).tolist()"""
+        # create a data grid always contains ifnom
+        excur = np.logspace(np.log(ifmin), np.log(ifnom),
+                            kwargs.get("num_exc_steps", 6) - 2,
+                            base=np.exp(1), endpoint=False).tolist()
+        excur.extend([ifnom, ifmax])
     else:
         excur = np.linspace(ifmin, ifmax,
                             kwargs.get("num_exc_steps", 6))
@@ -440,10 +445,6 @@ class SynchronousMachine(object):
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                return pcu
-
             res = so.minimize(
                 self.culoss, startvals, method='SLSQP',  # trust-constr
                 bounds=self.bounds,
@@ -469,10 +470,6 @@ class SynchronousMachine(object):
 
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                #logger.info("iqde %s --> pcu %f", iqde, pcu)
-                return pcu
             res = so.minimize(
                 self.culoss, startvals, method='SLSQP',  # trust-constr
                 bounds=self.bounds,
@@ -513,42 +510,38 @@ class SynchronousMachine(object):
          with minimal losses at max voltage"""
         iqde = self.iqd_tmech(torque, w1/2/np.pi/self.p)
         if np.linalg.norm(
-                self.uqd(w1, *iqde)) <= u1max*np.sqrt(2):
+            self.uqd(w1, *iqde)) <= u1max*np.sqrt(2):
             if log:
                 log(iqde)
             return (*iqde, torque)
-        #beta, i1 = betai1(iqde[0], iqde[1])
-        #iex = iqde[2]
-
-        #beta = 0 if torque>0 else np.pi
-        io = iqde[0], 0, iqde[2] #*iqd(beta, i1), iex
+        beta, i1 = betai1(iqde[0], iqde[1])
+        iex = iqde[2]
+        def ubeta(b):
+            return np.sqrt(2)*u1max - np.linalg.norm(
+                         self.uqd(w1, *iqd(b, i1), iex))
+        beta = -np.pi/4 if torque>0 else -3*np.pi/4
+        io = *iqd(beta, i1), iex
 
         #    logger.debug("--- torque %g io %s", torque, io)
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            n = w1/2/np.pi/self.p
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                #logger.info("iqde %s pcu %g", iqde, pcu)
-                return pcu
-
-            res = so.minimize(
-                self.culoss, io, method='SLSQP',  # trust-constr
-                bounds=self.bounds,
-                constraints=[
-                    {'type': 'eq',
-                     'fun': lambda iqd: torque - self.tmech_iqd(*iqd, n)},
-                    {'type': 'eq',
-                     'fun': lambda iqd: u1max*np.sqrt(2)
-                       - np.linalg.norm(self.uqd(w1, *iqd))}])
-            #if res['success']:
-            if log:
-                log(res.x)
+        n = w1/2/np.pi/self.p
+        res = so.minimize(
+            self.culoss, io, method='SLSQP',  # trust-constr
+            bounds=self.bounds,
+            constraints=[
+                {'type': 'eq',
+                 'fun': lambda iqd: self.tmech_iqd(*iqd, n) - torque},
+                {'type': 'eq',
+                 'fun': lambda iqd: np.linalg.norm(
+                     self.uqd(w1, *iqd)) - u1max*np.sqrt(2)}])
+
+        if log:
+            log(res.x)
+        if res["success"]:
             return *res.x, self.tmech_iqd(*res.x, n)
-        #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-        #               res['message'], w1, torque, u1max, io)
-        #raise ValueError(res['message'])
-        #return [float('nan')]*4
+
+        logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+                       res['message'], w1, torque, u1max, io)
+        raise ValueError(res['message'])
 
     def iqd_torque_umax(self, torque, w1, u1max,
                         disp=False, maxiter=500, log=0, **kwargs):
@@ -559,33 +552,31 @@ class SynchronousMachine(object):
                 if log:
                     log(iqde)
                 return (*iqde, torque)
-        io = iqde[0], 0, iqde[2]
-        #    logger.debug("--- torque %g io %s", torque, io)
-        with warnings.catch_warnings():
-            warnings.simplefilter("ignore")
-            def sqrtculoss(iqde):
-                pcu = self.culoss(iqde)
-                #logger.info("iqde %s pcu %g", iqde, pcu)
-                return pcu
-
-            res = so.minimize(
-                self.culoss, io, method='SLSQP',  # trust-constr
-                bounds=self.bounds,
-                #options={'disp': disp, 'maxiter': maxiter},
-                #            jac=gradient_respecting_bounds(self.bounds, self.culoss),
-                constraints=[
-                    {'type': 'eq',
-                     'fun': lambda iqd: self.torque_iqd(*iqd) - torque},
-                    {'type': 'eq',
-                     'fun': lambda iqd: u1max*np.sqrt(2) - np.linalg.norm(
-                         self.uqd(w1, *iqd))}])
-            #if res['success']:
-            if log:
-                log(res.x)
+        beta, i1 = betai1(iqde[0], iqde[1])
+        iex = iqde[2]
+        def ubeta(b):
+            return np.sqrt(2)*u1max - np.linalg.norm(
+                         self.uqd(w1, *iqd(b, i1), iex))
+        beta = -np.pi/4 if torque>0 else -3*np.pi/4
+        io = *iqd(beta, i1), iex
+        res = so.minimize(
+            self.culoss, io, method='SLSQP',  # trust-constr
+            bounds=self.bounds,
+            #options={'disp': disp, 'maxiter': maxiter},
+            #            jac=gradient_respecting_bounds(self.bounds, self.culoss),
+            constraints=[
+                {'type': 'eq',
+                 'fun': lambda iqd: self.torque_iqd(*iqd) - torque},
+                {'type': 'eq',
+                 'fun': lambda iqd: u1max*np.sqrt(2) - np.linalg.norm(
+                     self.uqd(w1, *iqd))}])
+        if log:
+            log(res.x)
+        if res['success']:
             return *res.x, self.torque_iqd(*res.x)
-            #logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
-            #               res['message'], w1, torque, u1max, io)
-            #raise ValueError(res['message'])
+        logger.warning("%s: w1=%f torque=%f, u1max=%f, io=%s",
+                       res['message'], w1, torque, u1max, io)
+        raise ValueError(res['message'])
 
     def w1_imax_umax(self, i1max, u1max):
         """return frequency w1 and shaft torque at voltage u1max and current i1max
@@ -669,10 +660,12 @@ class SynchronousMachine(object):
 
         wmtab = []
         dw = 0
+        wmMax = 2*np.pi*n
+        '''
         wmMax = 5*wmType
         if n > 0:
             wmMax = min(wmMax, 2*np.pi*n)
-
+        '''
         if wmType > wmMax:
             wmrange = sorted([0, wmMax])
             wmtab = np.linspace(0, wmMax, nsamples).tolist()
@@ -793,6 +786,7 @@ class SynchronousMachinePsidq(SynchronousMachine):
         self.psiqf = ip.RegularGridInterpolator(
             (exc, iqx, idx), psiq,
             method='cubic', bounds_error=False, fill_value=None)
+        # excitation currents bounds should respect ifnom
         self.bounds = [(min(iq), max(iq)),
                        (min(id), 0),
                        (iexc[0], iexc[-1])]
@@ -909,6 +903,7 @@ class SynchronousMachineLdq(SynchronousMachine):
             method='cubic'
             , bounds_error=False, fill_value=None)
         i1max = np.sqrt(2)*(max(i1))
+        # excitation currents bounds should respect ifnom
         self.bounds = [(np.cos(min(beta))*i1max, i1max),
                        (-i1max, 0),
                        (iexc[0], iexc[-1])]

femagtools/parstudy.py

@@ -140,7 +140,8 @@ class ParameterStudy(object):
 
     def __call__(self, opt, machine, simulation,
                  engine, bchMapper=None,
-                 extra_files=[], num_samples=0):
+                 extra_files=[], num_samples=0,
+                 data_model_created=False):
         """calculate objective vars for all decision vars
         Args:
           opt: variation parameter dict (decision_vars, objective_vars)
@@ -150,6 +151,8 @@ class ParameterStudy(object):
           bchMapper: bch result transformation function
           extra_files: list of additional input file names to be copied
           num_samples: number of samples (ingored with Grid sampling)
+          data_model_created: model and complete data structur
+                              was already created before calling this function
         """
 
         self.stop = False  # make sure the calculation will start. thomas.maier/OSWALD
@@ -174,7 +177,8 @@ class ParameterStudy(object):
             workdir = pathlib.Path(self.femag.workdir)
         for d in workdir.glob('[0-9]*'):
             if re.search(r'^\d+$', d.name):
-                shutil.rmtree(d)
+                if not data_model_created:
+                    shutil.rmtree(d)
 
         extra_result_files = []
         if simulation.get('airgap_induc', False):
@@ -190,13 +194,15 @@ class ParameterStudy(object):
             simulation['range_phi'] = 720/model.get('poles')
         except AttributeError: #  if dxf or pure fsl model
             simulation['range_phi'] = 0.0
-        simulation.update(model.winding)
+        try:
+            simulation.update(model.winding)
+        except AttributeError:
+            pass
         fea = femagtools.model.FeaModel(simulation)
 
         prob = femagtools.moproblem.FemagMoProblem(decision_vars,
                                                    objective_vars)
-
-        if immutable_model:
+        if not data_model_created and immutable_model:
             modelfiles = self.setup_model(builder, model, recsin=fea.recsin,
                                           feloss=simulation.get('feloss', ''))
             logger.info("Files %s", modelfiles+extra_files)
@@ -229,7 +235,10 @@ class ParameterStudy(object):
             fea.poc.pole_pitch = 2*360/model.get('poles')
             fea.pocfilename = fea.poc.filename()
         if not hasattr(fea, 'pocfilename'):
-            fea.pocfilename = f"{model.name}_{model.get('poles')}p.poc"
+            try:
+                fea.pocfilename = f"{model.name}_{model.get('poles')}p.poc"
+            except AttributeError:
+                logger.warning("Missing number of poles")
         elapsedTime = 0
         self.bchmapper_data = []  # clear bch data
         # split x value (par_range) array in handy chunks:
@@ -276,7 +285,7 @@ class ParameterStudy(object):
                 task = job.add_task(self.result_func)
                 for fn in extra_files:
                     task.add_file(fn)
-                if immutable_model:
+                if not data_model_created and immutable_model:
                     prob.prepare(x, [fea, self.femag.magnets])
                     for m in modelfiles:
                         task.add_file(m)
@@ -291,18 +300,21 @@ class ParameterStudy(object):
                 else:
                     prob.prepare(x, [model, fea, self.femag.magnets])
                     logger.info("prepare %s", x)
-                    for mc in self.femag.copy_magnetizing_curves(
-                            model,
-                            dir=task.directory,
-                            recsin=fea.recsin,
-                            feloss=feloss):
-                        task.add_file(mc)
-                    set_magnet_properties(model, fea, self.femag.magnets)
+                    if not data_model_created:
+                        for mc in self.femag.copy_magnetizing_curves(
+                                model,
+                                dir=task.directory,
+                                recsin=fea.recsin,
+                                feloss=feloss):
+                            task.add_file(mc)
+                        set_magnet_properties(model, fea, self.femag.magnets)
                     task.add_file(
                         'femag.fsl',
-                        builder.create_model(model, self.femag.magnets) +
+                        builder.create_model(model, self.femag.magnets) if not data_model_created else [] +
                         builder.create_analysis(fea) +
-                        ['save_model("close")'])
+                        ['save_model("close")'],
+                        append=data_model_created  # model already created, append fsl
+                    )
 
                 if hasattr(fea, 'poc'):
                     task.add_file(fea.pocfilename,

femagtools/plot/bch.py

@@ -527,23 +527,39 @@ def demagnetization(demag, ax=0):
     i1 = [scale*x for x in demag['i1']]
     ax.plot(i1, demag['rr'], 'o', color='C0')
     ax.plot(i1, demag['rr'], color='C0')
-    rrmin = 0.6
+    rrmin = min(0.6, np.min(demag['rr']))
+
+    Imax = scale*abs(demag['i1max'])
+    demaglabels = [f'Imax  = {Imax:.1f} {unit}']
     if demag.get('i1c', 0):
         Icrit = scale*demag['i1c']
-        Hk = demag['Hk']
-        Tmag = demag['Tmag']
-        di = 0.05*np.max(i1)
-        rrmin = min(0.6, np.min(demag['rr']))
-        ax.plot([Icrit, Icrit], [rrmin, 1], 'k--')
-        ax.annotate(
-            f'Icrit = {Icrit:.1f}{unit}\nHk = {Hk:.1f} kA/m\nTmag={Tmag:.1f} °C',
-            xy=(Icrit, rrmin),
-            xytext=(Icrit-di, rrmin+0.1*(1-rrmin)), ha='right',
+        ax.plot([Icrit, Icrit], [rrmin, 1], 'r:')
+        ax.text(Icrit, rrmin+0.15, 'Icrit', fontfamily='monospace',
+                rotation=90, size='large', ha='right', va='bottom')
+        demaglabels.append(f'Icrit = {Icrit:.1f} {unit}')
+
+    ax.plot([Imax, Imax], [rrmin, 1], 'g:')
+    ax.text(Imax, rrmin+0.05, 'Imax', fontfamily='monospace',
+                rotation=90, size='large', ha='right', va='bottom')
+
+    Hk = demag['Hk']
+    Tmag = demag['Tmag']
+    demaglabels += [f'Hk    = {Hk:.1f} kA/m',
+                    f'Tmag  = {Tmag:.1f} °C']
+
+    ax.text(0, rrmin+0.05,
+            '\n'.join(demaglabels),
+                fontfamily='monospace',
+            ha='left', va='bottom', size='large',
             bbox={'facecolor': 'white',
                   'edgecolor': 'white'})
+
+    #ax.annotate('Imax', xy=(Imax, demag['rr_i1max']), ha='center', va='bottom',
+    #               xytext=(Imax, demag['rr_i1max']-0.1), rotation=90,
+    #        arrowprops=dict(facecolor='green', edgecolor='green', shrink=0.05))
     ax.set_ylim([rrmin, 1.01])
     ax.set_ylabel('Rel. Remanence')
-    ax.set_xlabel(f'Phase Current / {unit}')
+    ax.set_xlabel(f'Phase Current / {unit} (peak)')
     ax.grid()
 
 

femagtools/shortcircuit.py

@@ -106,16 +106,24 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
                 encoding='latin1', errors='ignore'))
             bchsc.scData['demag'] = bchsc.demag
             if simulation.get('sim_demagn', 0):
-                d = {'displ': [d['displ']
+                dd = {'displ': [d['displ']
                                for d in bchsc.demag if 'displ' in d],
                      'H_max': [d['H_max']
                                for d in bchsc.demag if 'H_max' in d],
                      'H_av': [d['H_av']
                               for d in bchsc.demag if 'H_av' in d]}
-                simulation['i1max'] = bchsc.scData['iks']
+                x1 = bchsc.demag[0]['current_1']
+                x2 = bchsc.demag[0]['current_2']
+                def func(phi):
+                    return x2*np.cos(phi) - x1*np.cos(phi-2*np.pi/3)
+                phi=so.fsolve(func, 0)[0]
+                i1max = x1/np.cos(phi)
+
+                phirot = dd['displ'][0]/180*np.pi
                 bchsc.scData['demag'] = demag(
-                    femag, machine, simulation, engine)
-                bchsc.scData['demag'].update(d)
+                    femag, machine, simulation,
+                    i1max, phirot, phi, engine)
+                bchsc.scData['demag'].update(dd)
             scdata = bchsc.scData
             #for w in bch.flux:
             #    try:
@@ -129,7 +137,7 @@ def shortcircuit(femag, machine, bch, simulation, engine=0):
     if simulation.get('sc_type', 3) == 2:
         if 'i1max' not in simulation:
             # just a wild guess
-            simulation['i1max'] = 4.5*bch.machine['i1']
+            simulation['i1max'] = 5*bch.machine['i1']
         logger.info("2phase short circuit simulation i1max = %.0f",
                     simulation['i1max'])
         scdata = shortcircuit_2phase(femag, machine, simulation, engine)
@@ -161,12 +169,13 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
     num_cur_steps = 4
     i1 = np.linspace(0, i1max, num_cur_steps)
     i1vec = np.concat((-i1[::-1], i1[1:]))
-    num_par_wdgs = machine['winding'].get('num_par_wdgs', 1)
     flux_sim = {
         'calculationMode': 'psi-torq-rot',
         'i1max': i1max,
         'curvec': [],
-        'num_par_wdgs': num_par_wdgs}
+        'magntemp': simulation['magn_temp'],
+        'fc_radius': simulation['fc_radius'],
+        'num_par_wdgs': simulation['num_par_wdgs']}
 
     if engine:
         parstudy = _parstudy_list(femag, sc_result_func)
@@ -304,6 +313,11 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
     logger.info("Torque %.1f %.1f %.1f (dphi %.4f)",
                 tp[1], tv[1], tc[1], dphi)
 
+    # rotor position at maximum current:
+    trot = min(iav[0], iap[0])
+    phirot = wm*trot + phi0
+    logger.info("phi %.1f")
+
     scData = {
         'ia': ia.tolist(),
         'ib': (-ia).tolist(),
@@ -316,63 +330,53 @@ def shortcircuit_2phase(femag, machine, simulation, engine=0):
         'iks': iap[1] if iap[1] > abs(iav[1]) else iav[1],
         'tks': tp[1] if tp[1] > abs(tv[1]) else tv[1]
     }
-    scData['peakWindingCurrents'] = [scData['iks'],
-                                     -scData['iks'], 0]
+    scData['peakWindingCurrents'] = [float(scData['iks']),
+                                     -float(scData['iks']), 0]
     if simulation.get('sim_demagn', 0):
-        scData['demag'] = demag(femag, machine, simulation, engine)
+        i1max = iap[1] if iap[1] > abs(iav[1]) else iav[1]
+        scData['demag'] = demag(femag, machine, simulation,
+                                i1max, phirot, 0, engine)
     return scData
 
-def dm_result_func(task):
-    basedir = pathlib.Path(task.directory)
-    i1rr = []
-    for f in sorted(basedir.glob('psi-torq-rem-rot-*.dat')):
-        ptr = np.loadtxt(f)
-        i1rr.append((np.max(ptr.T[1:4]), np.min(ptr.T[-1])))
-    return i1rr
-
-def demag(femag, machine, simulation, engine=0):
+def demag(femag, machine, simulation, i1max, phirot, phi, engine=0):
     """demag simulation using psi-torq-rem-rot"""
     logger.info("Demagnetization processing")
-    i1max = simulation['i1max']
-    i1min = simulation.get('i1min', i1max/4)
+    i1min = simulation.get('i1min', abs(i1max/3))
     num_steps = 7
-    b = (i1min-i1max)/np.log(i1min/i1max)
-    a = i1max/b
-    i1tab = [b*(a+np.log(x))
-             for x in np.linspace(i1min/i1max, 1,
-                                  num_steps)]
+    b = (i1min-abs(i1max))/np.log(i1min/abs(i1max))
+    a = abs(i1max)/b
+    xtab = np.linspace(i1min/abs(i1max),
+                       1+2*(1-i1min/abs(i1max))/(num_steps-1), num_steps+2)
+    i1tab = b*(a+np.log(xtab))
 
     if simulation.get('sc_type', 3) == 3:
-        curvec = [[-a/2, a, -a/2] for a in i1tab]
+        curvec = [[a*np.cos(phi), a*np.cos(phi-2*np.pi/3),
+                   a*np.cos(phi+2*np.pi/3)] for a in i1tab]
     else:
-        curvec = [[a, -a, 0] for a in i1tab]
+        if i1max > 0:
+            curvec = [[a, -a, 0] for a in i1tab]
+        else:
+            curvec = [[-a, a, 0] for a in i1tab]
     simulation.update({
-        'calculationMode': 'psi-torq-rem-rot',
+        'calculationMode': 'psi-torq-rem',
+        'phi': phirot,
+        'magntemp': simulation['Tmag'],
         'curvec': curvec})
-    if engine:
-        parstudy = _parstudy_list(femag, dm_result_func)
-        parvardef = {
-            "decision_vars": [
-                {"values": curvec, "name": "curvec"}]
-        }
-        results = parstudy(parvardef, machine, simulation, engine)
-        i1rr = np.vstack(
-            ((0, 1),
-             np.array(results['f']).reshape((-1, 2))))
-    else:
-        class Task:
-            def __init__(self, workdir):
-                self.directory = workdir
-        _ = femag(machine, simulation)
-        i1rr = np.vstack(
-            [(0, 1), dm_result_func(Task(femag.workdir))])
-    i1, rr = np.array(i1rr).T
+    _ = femag(machine, simulation)
+
+    ptr = np.loadtxt(femag.workdir / "psi-torq-rem.dat")
+    i1 = np.concat(([0], np.max(ptr[:,1:4], axis=1)))
+    rr = np.concat(([1], ptr[:,-1]))
     dmag = {'Hk': simulation['Hk'],
             'Tmag': simulation['Tmag'],
             'i1': i1.tolist(),
+            'i1max': float(np.abs(i1max)),
             'rr': rr.tolist()}
     # critical current
     if np.min(rr) < 0.99:
-        k = np.where(rr < 0.99)[0][0]
-        dmag['i1c'] = i1[k]
+        k = np.where(np.diff(dmag['rr'])<-1e-3)[0][0]+1
+        dmag['i1c'] = float(i1[k])
+        if abs(i1max) < i1[-1]:
+            rrf = make_interp_spline(i1, rr)
+            dmag['rr_i1max'] = float(rrf(abs(i1max)))
     return dmag

femagtools/templates/ec-rotorbar.mako

@@ -6,7 +6,8 @@ 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(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
                        sigma2, muer, rel, "polar", 0, 0)
 Abar = get_sreg_data("area",rotorbar)
 

femagtools/templates/gen_hairpin_winding.mako

@@ -2,11 +2,11 @@
 
 slot_div_angle = 360/m.tot_num_slot
 
-if m.xcoil_1 ~= nil and m.ycoil_1 ~= nil then 
+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 
+end
 
 -- delete existing mesh in the slot
 for i = 1, m.num_sl_gen do
@@ -173,11 +173,11 @@ for i = 1, #winding do
     slot_nr = winding[i][2]
     layer = winding[i][3]
     direction = winding[i][4]
-    if direction < 0 then 
+    if direction < 0 then
       dir = 'wo'
     else
       dir = 'wi'
-    end 
+    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)
@@ -188,7 +188,7 @@ for i = 1, #winding do
               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)
@@ -197,4 +197,6 @@ for i = 1, #winding do
           end
    end
 end
-m.num_par_wdgs = ${model.get('num_par_wdgs', 1)}
+m.num_par_wdgs = ${model.get('num_par_wdgs', 1)}
+
+pre_models("gen_pocfile")

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,6 +19,7 @@ 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)

femagtools/templates/noloadflux-rot.mako

@@ -106,9 +106,13 @@ rotate({
 })
 
 file_psi = io.open("psi-rot-mag.dat","w")
+value={}
+temp={}
 for n=1,nrot+1 do
 
   pos, bag = calc_field(phi, curvec, file_psi)
+  value[n]=#pos
+  temp[n]=pos
   bags[n] = bag
   phi = n*dphi
   rotate({angle=phi, mode="absolute"})
@@ -116,16 +120,40 @@ end
 rotate({mode = "reset"})  -- restore the initial state (discard any changes)
 file_psi:close()
 
+-- add otherwise nil value in bags[n][i][k]
+for i=1, #value-1 do
+  if value[i]<value[i+1] then
+    num_pos=value[i]
+  end
+end 
+-- end
+
+--for i=1, #curvec do
+--  bagfile = string.format("noloadbag-%d.dat", i)
+--  file_bag = io.open(bagfile,"w")
+--  for k = 1, num_pos do --#pos do -- add otherwise nil value in bags[n][i][k]
+--     file_bag:write(string.format("%g ", pos[k]))
+--     for n=1, nrot+1 do
+--      file_bag:write(string.format("%g ",
+--         bags[n][i][k]))  -- Br, rotpos, cur, pos
+--     end
+--     file_bag:write("\n")
+--  end
+--  file_bag:close()
+--end
+
+-- add otherwise nil value in bags[n][i][k]
 for i=1, #curvec do
   bagfile = string.format("noloadbag-%d.dat", i)
   file_bag = io.open(bagfile,"w")
-  for k = 1, #pos do
-     file_bag:write(string.format("%g ", pos[k]))
-     for n=1, nrot+1 do
+  for n=1, nrot+1 do
+     for k = 1, value[n] do --#pos do 
+      pos=temp[n]
+      file_bag:write(string.format("%g ", pos[k]))
       file_bag:write(string.format("%g ",
          bags[n][i][k]))  -- Br, rotpos, cur, pos
      end
      file_bag:write("\n")
   end
   file_bag:close()
-end
+end