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

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.12'
+__version__ = '1.8.13'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2025 Gamma Technology'

femagtools/bch.py

@@ -7,6 +7,7 @@ import numpy as np
 import re
 import logging
 import logging.config
+from .utils import fft
 
 logger = logging.getLogger('femagtools.bch')
 
@@ -1375,10 +1376,14 @@ class Reader:
             try:
                 w1 = np.pi*self.dqPar['speed']*self.dqPar['npoles']
                 r1 = self.machine.get('r1', 0.0)
-                uq, ud = (r1*iq + self.dqPar['up'] + id*w1*self.dqPar['ld'][0],
-                          r1*id - iq*w1*self.dqPar['lq'][0])
-                self.dqPar['u1'] = [np.sqrt(uq**2 + ud**2)]
-                self.dqPar['gamma'] = [-np.arctan2(ud, uq)*180/np.pi]
+                pos = self.flux['1'][0]['displ']
+                emfft = [fft(pos, f['voltage_dpsi']) for f in self.flux['1']]
+                gamma = [emfft[0]['alfa0'] - e['alfa0'] for e in emfft[1:]]
+                emf = np.array([e['a']/np.sqrt(2) for e in emfft[1:]])
+                uq, ud = r1*iq + np.cos(gamma)*emf, r1*id + np.sin(gamma)*emf
+                self.dqPar['u1'] = np.sqrt(uq**2 + ud**2).tolist()
+                self.dqPar['gamma'] = (-np.arctan2(ud, uq)*180/np.pi).tolist()
+
                 self.dqPar['psim0'] = lfe*self.dqPar['psim0']
                 self.dqPar['phi'] = [self.dqPar['beta'][0] +
                                      self.dqPar['gamma'][0]]
@@ -1386,16 +1391,20 @@ class Reader:
                                         for phi in self.dqPar['phi']]
                 self.dqPar['i1'].insert(0, 0)
                 self.dqPar['u1'].insert(0, self.dqPar.get('up0', 0))
+
             except KeyError:
                 pass
 
-            # if next section is absent
             try:
-                self.dqPar['psid'] = [self.dqPar['psim'][0]]
-                self.dqPar['psiq'] = [self.dqPar['lq'][0] *
-                                      self.dqPar['i1'][-1]]
-            except KeyError:
-                pass
+                self.dqPar['psid'] = np.cos(gamma)*emf/w1
+                self.dqPar['psiq'] = -np.sin(gamma)*emf/w1
+            except UnboundLocalError:
+                try:
+                    self.dqPar['psid'] = [self.dqPar['psim'][0]]
+                    self.dqPar['psiq'] = [self.dqPar['lq'][0] *
+                                          self.dqPar['i1'][-1]]
+                except KeyError:
+                    pass
             return  # end of first section
 
         # second DQ-Parameter section
@@ -1612,8 +1621,8 @@ class Reader:
 
                     elif content[i+1].split() == ['Iron', '----']:
                         losses['rotfe'] = sum([floatnan(x) for x in rec])
-                        losses['total'] += losses['rotfe']    
-                        
+                        losses['total'] += losses['rotfe']
+
                     else:
                         losses['rotfe'] = floatnan(rec[1])
                         losses['total'] += losses['rotfe']

femagtools/ecloss.py

@@ -263,10 +263,11 @@ class MagnLoss:
                                    for i in range((npos-1)//2 + 1) if i > 0])
             npos_nonzero = np.argwhere(tmp_period > 0.1*np.amax(bxy_amp)).squeeze()
             period = tmp_period[npos_nonzero]
-
             if np.sum(np.around([period[0]%i for i in period])) == 0:
-                npos = min(int(np.ceil(np.amax(period))+1), bxy.shape[2])
-
+                try:
+                    npos = min(int(np.ceil(np.amax(period))+1), bxy.shape[2])
+                except:
+                    pass
         try:
             self.tgrid = 60/self.speed*(self.theta[npos-1] - self.theta[0])/360
         except AttributeError:
@@ -765,7 +766,12 @@ class MagnLoss:
                             i["wm"]*1e3, i["hm"]*1e3, i["lm"]*1e3,
                             (nsegx, nsegy, nsegz))
 
-                (nt, bx_fft, by_fft) = self.periodicity_id(i['bl'])  # finds the time periodic part of the simulation
+                (nt, bx_fft, by_fft) = self.periodicity_id(i['bl'])
+                if self.tgrid == 0:
+                    logger.warning(f"Time series couldn't be identified. Cannot calculate losses \
+                                   for loadcase {i['loadcase']}, superelement {i['spel_key']}")
+                    all_load_cases.append(0)
+                    continue
                 (nx, ny, nz, excpl_new, eycpl_new) = Segmentation(
                     i['wm'], i['hm'], i['lm'], i['elcp'],
                     nsegx, nsegy, nsegz)
@@ -778,6 +784,8 @@ class MagnLoss:
                     nx, ny, nsegx, nsegy, nt, i['elcp'], i['bl'], excpl_new, eycpl_new)
                 loss = self.loss_ialh2(sx_abs, sy_abs, sx_phase, sy_phase, freq_range,
                                        nx, ny, wm, hm, lm, nsegx, nsegy, nsegz, delta_eff) * self.numpoles
+                if np.isnan(loss):
+                    loss = 0
                 ialh_loss += loss
                 logger.info('Loadcase %d, Superelement %s, Total losses =  %.3f W',
                             i["loadcase"], i["spel_key"], loss)

femagtools/femag.py

@@ -475,9 +475,8 @@ class BaseFemag(object):
             if simulation.get('magnet_loss', False):
                 logger.info('Evaluating magnet losses...')
                 ops = range(len(bch.torque))
-                ncf = pathlib.Path(self.workdir) / self.modelname
                 m = femagtools.ecloss.MagnLoss(
-                    nc=femagtools.nc.read(ncf), ibeta=ops)
+                    nc=self.read_nc(), ibeta=ops)
                 try:
                     # change from ialh to ialh2: since v1.8.1
                     magn_losses = m.calc_losses_ialh2()

femagtools/fsl.py

@@ -287,12 +287,20 @@ class Builder:
             if 'dxf' in rotmodel:
                 return mcv + ['ndt(agndst)'] + rotmodel['dxf']['fsl']
             templ = 'rot_hsm'
+        if templ == 'rotorKs2':
+            if 'dxf' in rotmodel:
+                return mcv + ['ndt(agndst)'] + rotmodel['dxf']['fsl']
+            templ = 'rotorKs2'
         rotmodel.update(model.rotor[templ])
         return mcv + culosses + self.render_rotor(rotmodel, templ)
 
     def create_rotor_winding(self, model):
+        if 'ecSimulation' in model.stator:
+            return self.render_rotor(model.rotor, 'rotor_winding_ks2_ecSimulation')
         if hasattr(model, 'rotor') and model.rotortype() == 'EESM':
             return self.render_rotor(model.rotor, 'rotor_winding')
+        if hasattr(model, 'rotor') and model.rotortype() == 'rotorKs2':
+            return self.render_rotor(model.rotor, 'rotor_winding_ks2')
         return []
 
     def prepare_magnet(self, model):
@@ -506,8 +514,11 @@ class Builder:
         params['nodedist'] = fmt.get('nodedist', 1)
         params['full_model'] = fmt.get('full_model', False)
         params['EESM'] = fmt.get('type', 'PMSM') == 'EESM'
+        params['rotorKs2'] = fmt.get('type', 'PMSM') == 'rotorKs2'
         if params['EESM']:
             model.rotor['EESM'] = {}
+        if params['rotorKs2']:
+            model.rotor['rotorKs2'] = {}
         conv = convert(fname, **params)
 
         model.set_value('poles', conv.get('num_poles'))
@@ -550,6 +561,8 @@ class Builder:
         if not (hasattr(model, 'magnet') or hasattr(model, 'rotor')):
             if params['EESM']:
                 setattr(model, 'rotor', {})
+            elif params['rotorKs2']:
+                setattr(model, 'rotor', {})
             else:
                 setattr(model, 'magnet', {})
 
@@ -659,14 +672,20 @@ class Builder:
                         self.mesh_airgap(model) +
                         self.create_connect_models(model) +
                         self.create_rotor_winding(model))
-            if 'statorRing' in model.stator:
+            if 'statorRing' in model.stator and 'ecSimulation' not in model.stator:
+                return (self.create_new_model(model) +
+                        self.create_cu_losses(windings, condMat, ignore_material) +
+                        self.create_fe_losses(model) +
+                        rotor +
+                        self.create_stator_model(model) +
+                        self.create_rotor_winding(model))
+            if 'ecSimulation' in model.stator:
                 return (self.create_new_model(model) +
                         self.create_cu_losses(windings, condMat, ignore_material) +
                         self.create_fe_losses(model) +
                         rotor +
                         self.create_stator_model(model) +
                         self.create_rotor_winding(model))
-
             return (self.create_new_model(model) +
                     self.create_cu_losses(windings, condMat, ignore_material) +
                     self.create_fe_losses(model) +
@@ -770,6 +789,12 @@ class Builder:
         else:
             plots = []
 
+        if sim.get('calculationMode') in ('cogg_calc',
+                                          'ld_lq_fast',
+                                          'pm_sym_loss',
+                                          'torq_calc',
+                                          'psd_psq_fast'):
+            return felosses + fslcalc + self.__render(sim, 'plots')
         return felosses + fslcalc + plots
 
     def create_shortcircuit(self, model):
@@ -858,7 +883,6 @@ class Builder:
                 self.fsl_stator = True
             if magnet:
                 self.fsl_rotor = True
-
         return template.render_unicode(model=model).split('\n')
 
     def render_template(self, content_template, parameters):

femagtools/job.py

@@ -76,12 +76,14 @@ class Task(object):
     def set_stateofproblem(self, stateofproblem):
         self.stateofproblem = stateofproblem
 
-    def add_file(self, fname, content=None):
+    def add_file(self, fname, content=None, append=False):
         """adds a file required by this task
 
         Args:
             fname: file name
-            content: list of str written to file if not None"""
+            content: list of str written to file if not None
+            append: append file mode if true
+        """
         base = os.path.basename(fname)
         self.transfer_files.append(fname)
         if os.path.splitext(base)[-1] == '.fsl':
@@ -94,7 +96,8 @@ class Task(object):
             return
 
         # this file has to be created
-        with open(os.path.join(self.directory, base), 'w') as f:
+        fmode = 'a' if append else 'w'
+        with open(os.path.join(self.directory, base), fmode) as f:
             f.writelines('\n'.join(content))
 
     def get_results(self):

femagtools/machine/__init__.py

@@ -38,7 +38,6 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
         opts['rotor_mass'] = rlfe*eecpars['rotor_mass']
     except KeyError:
         pass
-
     if 'ldq' in eecpars or 'psidq' in eecpars:  # this is a PM (or EESM)
         try:
             dqpars = eecpars['ldq']
@@ -65,8 +64,8 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
             logger.warning(
                 "single temperature DQ parameters: unable to fit temperature %s", temp)
 
-        psid = rwdg*rlfe*dqp['psid']
-        psiq = rwdg*rlfe*dqp['psiq']
+        psid = rwdg*rlfe*np.array(dqp['psid'])
+        psiq = rwdg*rlfe*np.array(dqp['psiq'])
         losses = __scale_losses(dqp['losses'], rlfe)
         losses['ef'] = dqpars[-1]['losses'].get('ef', [2.0, 2.0])
         losses['hf'] = dqpars[-1]['losses'].get('hf', [1.0, 1.0])
@@ -114,9 +113,42 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
     pars['psi'] = [psi*rwdg*rlfe for psi in pars['psi']]
     pars['tcu1'] = temp[0]
     pars['tcu2'] = temp[1]
+
     pars.update(opts)
     return InductionMachine(pars)
+    
+
+def create_from_eecpars_im(temp, eecpars, lfe=1, wdg=1):
+    rlfe = lfe
+    rwdg = wdg
+
+    eecpars_new=eecpars['opResults']
+    opts = {k: eecpars_new[k] for k in ('zeta1', 'gam', 'kh', 'kpfe',
+                                    'kfric_b', 'kpmag') if k in eecpars_new}
+
+    pars = copy.deepcopy(eecpars_new)
+
+    pars['r1'] = rlfe*rwdg**2*pars.get('r1', 0)
+    pars['lsigma1'] = rlfe*pars['lsigma1']
+    pars['lsigma2'] = rlfe*pars['lsigma2']
+    pars['psiref'] = rwdg*rlfe*pars['psiref']
+    pars['u1ref'] = rwdg*rlfe*pars['u1ref']
+    pars['r2'] = rlfe*pars['r2']
+    pars['fec'] = rlfe*pars['fec']
+    pars['fee'] = rlfe*pars['fee']
+    pars['im'] = [im/rwdg for im in pars['im']]
+    pars['psi'] = [psi*rwdg*rlfe for psi in pars['psi']]
+    pars['tcu1'] = temp[0]
+    pars['tcu2'] = temp[1]
+    pars['nmax'] = eecpars['op']['nmax']
+    pars['umax'] = eecpars['op']['umax']
+    #pars['u1'] = eecpars['genDesign']['u1']
+    pars['Tmax'] = eecpars['op']['Tmax']
+    pars['p'] = eecpars['genDesign']['p']
+    pars['m'] = eecpars['genDesign']['m']
 
+    pars.update(opts)
+    return InductionMachine(pars)
 
 def create(bch, r1, ls, lfe=1, wdg=1):
     """create PmRelMachine from BCH

femagtools/machine/effloss.py

@@ -10,7 +10,7 @@ from . import create_from_eecpars
 logger = logging.getLogger("femagtools.effloss")
 
 
-def iqd_tmech_umax(m, u1, with_mtpa, progress, speed_torque, iq, id, iex):
+def iqd_tmech_umax(m, u1, with_mtpa, with_tmech, progress, speed_torque, iq, id, iex):
     """calculate iq, id for each load (n, T) from speed_torque at voltage u1
 
         Args:
@@ -25,9 +25,14 @@ def iqd_tmech_umax(m, u1, with_mtpa, progress, speed_torque, iq, id, iex):
     num_iv = round(nsamples/7)
     try:
         for i, nT in enumerate(speed_torque):
-            iqde = m.iqd_tmech_umax(
-                nT[1], 2*np.pi*nT[0]*m.p,
-                u1, with_mtpa=with_mtpa)[:-1]
+            if with_tmech:
+                iqde = m.iqd_tmech_umax(
+                    nT[1], 2*np.pi*nT[0]*m.p,
+                    u1, with_mtpa=with_mtpa)[:-1]
+            else:
+                iqde = m.iqd_torque_umax(
+                    nT[1], 2*np.pi*nT[0]*m.p,
+                    u1, with_mtpa=with_mtpa)[:-1]
             iq[i] = iqde[0]
             id[i] = iqde[1]
             if len(iqde) > 2:
@@ -39,7 +44,8 @@ def iqd_tmech_umax(m, u1, with_mtpa, progress, speed_torque, iq, id, iex):
     finally:
         progress.close()
 
-def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa, publish=0):
+def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa, with_tmech,
+                         publish=0):
     """calculate iqd for sm and pm using multiproc
     """
     progress_readers = []
@@ -59,7 +65,7 @@ def iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa, publish=0):
             iex.append(multiprocessing.Array('d', chunksize))
             iexk = iex[k]
         p = multiprocessing.Process(target=iqd_tmech_umax,
-                                    args=(m, u1, with_mtpa,
+                                    args=(m, u1, with_mtpa, with_tmech,
                                           prog_writer,
                                           ntmesh.T[i:i+chunksize],
                                           iq[k], id[k], iexk))
@@ -254,14 +260,26 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
                                     rb['n'], rb['T'], npoints)
     else:
         nt = []
-        iq, id = m.iqd_torque(T[-1])
+        if isinstance(m, (SynchronousMachineLdq, SynchronousMachinePsidq)):
+            iq, id, iex = m.iqd_torque(T[-1])
+        else:
+            iq, id = m.iqd_torque(T[-1])
+
         i1max = betai1(iq, id)[1]
         logger.info("%s %s", n, T)
         for nx in n:
             w1 = 2*np.pi*nx*m.p
-            iq, id, tq =  m.iqd_imax_umax(i1max, w1, u1, T[-1],
-                                          with_tmech=with_tmech,
-                                          with_mtpa=with_mtpa)
+            if isinstance(m, (SynchronousMachineLdq, SynchronousMachinePsidq)):
+                if with_tmech:
+                    iq, id, iex, tq = m.iqd_tmech_umax(
+                        T[-1], w1, u1)
+                else:
+                    iq, id, iex, tq = m.iqd_torque_umax(
+                        T[-1], w1, u1)
+            else:
+                iq, id, tq =  m.iqd_imax_umax(i1max, w1, u1, T[-1],
+                                            with_tmech=with_tmech,
+                                            with_mtpa=with_mtpa)
             if np.isclose(tq, T[-1]):
                 tq = T[-1]
             for Tx in T:
@@ -276,7 +294,8 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
     if isinstance(m, (PmRelMachine, SynchronousMachine)):
         if num_proc > 1:
             iqd = iqd_tmech_umax_multi(num_proc, ntmesh, m, u1, with_mtpa,
-                                       publish=progress)
+                                       with_tmech, publish=progress)
+
         else:
             class ProgressLogger:
                 def __init__(self, nsamples, publish):
@@ -353,8 +372,13 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plfe2 = m.kpfe*m.iqd_plfe2(*iqd, f1)
         plmag = np.zeros_like(plfe2)
         plcu1 = m.iqd_plcu1(iqd[0], iqd[1], 2*np.pi*f1)
-        plcu1_dc = [] # reserved for winding (dc, ac) losses
-        plcu1_ac = []
+        try:
+            plcu1_dc = m.iqd_plcu1(iqd[0], iqd[1],
+                                np.array([0.0 for i in f1])).tolist()
+            plcu1_ac = [i-j for i, j in zip(plcu1.tolist(), plcu1_dc)]
+        except:
+            plcu1_dc, plcu1_ac = [], []
+
         plcu2 = m.iqd_plcu2(*iqd)
         tfric = m.tfric
         logger.info("Iex %f %f",

femagtools/machine/im.py

@@ -119,6 +119,7 @@ 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
@@ -603,7 +604,6 @@ class InductionMachine(Component):
                 r['eta'] += (pmech[i:]/(p1[i:])).tolist()
             else:
                 r['eta'] += (p1[i:]/pmech[i:]).tolist()
-
         return r
 
 
@@ -660,7 +660,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 +668,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
@@ -722,7 +722,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 +740,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,6 +754,8 @@ 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())
@@ -767,7 +769,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
         task.add_file(mc)
     task.add_file(
         'femag.fsl',
-        builder.create_model(barmodel,
+        builder.create_model(barmodel_new,
                              condMat=parstudy.femag.condMat) +
         builder.create_analysis(ecsim) +
         ['save_model("close")'])
@@ -796,6 +798,7 @@ def parident(workdir, engine, f1, u1, wdgcon,
     logger.info("Elapsed 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]

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),
@@ -574,6 +574,8 @@ def get_im_rotor_dimensions(A, Da2, psi1, lfe, par, rtype='rotorKs2'):
     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':
         r['statorRotor3'] = dict(
             slot_width=slotwidth,
@@ -985,13 +987,12 @@ 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)