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

femagtools/__init__.py

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

femagtools/bch.py

@@ -115,6 +115,22 @@ def losses_mapping_external_rotor(losses):
         pass
     return d
 
+def _convert(obj):
+    """make dict jsonizable"""
+    if isinstance(obj, dict):
+        return {k: _convert(v) for k, v in obj.items()}
+    elif isinstance(obj, (np.float32, np.float64)):
+        return float(obj)
+    elif isinstance(obj, list):
+        return [_convert(k) for k in obj]
+    elif isinstance(obj, tuple):
+        return tuple(_convert(k) for k in obj)
+    elif isinstance(obj, np.ndarray):
+        return obj.tolist()
+    elif isinstance(obj, (np.int32, np.int64)):
+        return int(obj)
+    else:
+        return obj
 
 def _readSections(f):
     """return list of bch sections
@@ -404,6 +420,11 @@ class Reader:
             self.windings[w[0]]['N'].append(w[2])
             self.windings[w[0]]['R'].append(w[3]/1e3)
             self.windings[w[0]]['PHI'].append(w[4])
+        # check if external rotor
+        if hasattr(self, "machine"): 
+            if "fc_radius" in self.machine:
+                if np.mean(self.windings[1]["R"]) < self.machine["fc_radius"]:
+                    self.external_rotor = True
 
     def __read_winding_factors(self, content):
         "read winding factors section"
@@ -1058,11 +1079,14 @@ class Reader:
         e.g. : idList[-450, -350, -250, -150, -50, 0]
                idList[-500, -400, -300, -200, -100, 0, 0]
         '''
-        if list(idList).count(0) > 1: # femag writes duplicate id==0 values
+        if list(idList).count(0) > 1:  # femag may write duplicate id==0 values
             idList = idList[:-1]
         diff = np.floor(np.abs(np.diff(idList)))
-        if n := np.trim_zeros(np.diff(diff)).size:
-            idList = idList[:-n]
+        maxdiff = np.max(diff)
+        # also remove samples that are close
+        if n := np.trim_zeros(np.diff(
+                np.round(diff/maxdiff, 2))).size:
+            return idList[:-n]
         return idList
 
     def __read_psidq(self, content):
@@ -1183,10 +1207,7 @@ class Reader:
         m = []
         subregs = [name.split()[-1]
                    for name in content[2].split('\t') if name][2:]
-        # outer rotor motor
-        if 'Iron' in subregs and \
-            'Rotor' in subregs:
-            self.external_rotor = True
+
         logger.info("Stator Subregions: %s", subregs)
         speed = float(content[0].split()[-1])/60.
         logger.info('losses for speed %f', speed)
@@ -1396,8 +1417,8 @@ class Reader:
                 pass
 
             try:
-                self.dqPar['psid'] = np.cos(gamma)*emf/w1
-                self.dqPar['psiq'] = -np.sin(gamma)*emf/w1
+                self.dqPar['psid'] = list(np.cos(gamma)*emf/w1)
+                self.dqPar['psiq'] = list(-np.sin(gamma)*emf/w1)
             except UnboundLocalError:
                 try:
                     self.dqPar['psid'] = [self.dqPar['psim'][0]]
@@ -1405,6 +1426,8 @@ class Reader:
                                           self.dqPar['i1'][-1]]
                 except KeyError:
                     pass
+
+            self.dqPar = _convert(self.dqPar)
             return  # end of first section
 
         # second DQ-Parameter section
@@ -1476,6 +1499,7 @@ class Reader:
             self.dqPar['u1'].insert(0, self.dqPar.get('up0', 0))
         except:
             pass
+        self.dqPar = _convert(self.dqPar)
 
     def __read_weights(self, content):
         #              Stator-Iron      - Conductors      - Magnets
@@ -1845,6 +1869,9 @@ def read(filename):
 
 if __name__ == "__main__":
     import json
+    logging.basicConfig(level=logging.INFO,
+                        format='%(asctime)s %(message)s')
+
     if len(sys.argv) == 2:
         filename = sys.argv[1]
     else:

femagtools/femag.py

@@ -153,7 +153,7 @@ class BaseFemag(object):
         dest = dir if dir else self.workdir
         if isinstance(feloss, (int, float)):
             try:
-                feloss = {1: 'jordan', 11: 'bertotti'}[int(feloss)]
+                feloss = {1: 'jordan', 2: "steinmetz", 10:"modified steinmetz", 11: 'bertotti'}[int(feloss)]
             except KeyError:
                 feloss = ''
         return [self.magnetizingCurves.writefile(m[0], dest,
@@ -188,6 +188,11 @@ class BaseFemag(object):
             recsin = simulation.get('recsin', '')
             feloss = simulation.get('calc_fe_loss', '')
         self.copy_magnetizing_curves(self.model, recsin=recsin, feloss=feloss)
+
+        if feloss and \
+            int(feloss) in (1, 2):
+            simulation["calc_fe_loss"] = 1
+
         try:
             if 'wdgdef' in self.model.winding:
                 self.model.winding['wdgfile'] = self.create_wdg_def(
@@ -485,6 +490,8 @@ class BaseFemag(object):
 
                 if len(ops) != len(bch.losses):
                     magn_losses.insert(0, magn_losses[0])
+                
+                magn_losses = [float(i) for i in magn_losses]
                 try:
                     for i in range(len(bch.losses)):
                         bch.losses[i].update({"magnetH": magn_losses[i]})

femagtools/fsl.py

@@ -287,20 +287,12 @@ 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):
@@ -444,25 +436,38 @@ class Builder:
         return self.__render(windings, 'cu_losses')
 
     def create_fe_losses(self, model):
-        for part in ('stator', 'rotor', 'commutator', 'magnet'):
+        fe_losses = []
+        fe_losses_items = (
+            'ffactor', 'cw', 'ch', 'hyscoef',
+            'edycof', 'indcof', 'fillfact',
+            'fillfac', 'basfreq', 'basind',
+            'ffactor')
+
+        part = 'stator'
+        if model.get(part, 0):
+            submod = model.get(part)
+            if any([submod.get(k, 0) for k in fe_losses_items]):
+                if submod.get('fillfac', 0):
+                    submod['fillfact'] = submod['fillfac']
+                fe_losses += self.__render(submod, 'FE-losses')
+                fe_losses.append('pre_models("FE-Losses-1")')
+
+        for part in ('rotor', 'commutator', 'magnet'):
             if model.get(part, 0):
                 submod = model.get(part)
-                if any(submod.get(k, 0) for k in (
-                        'ffactor', 'cw', 'ch', 'hyscoef',
-                        'edycof', 'indcof', 'fillfact',
-                        'fillfac','basfreq', 'basind',
-                        'ffactor')):
+                if any([submod.get(k, 0) for k in fe_losses_items]):
                     if submod.get('fillfac', 0):
                         submod['fillfact'] = submod['fillfac']
-                    return self.__render(submod, 'FE-losses')
-        return []
+                    fe_losses += self.__render(submod, 'FE-losses')
+                    fe_losses.append('pre_models("FE-Losses-2")')
+        return fe_losses
 
     def create_gen_winding(self, model):
         try:
             model.winding['wire'].update(
                 {"num_layers": model.winding["num_layers"]})
             genwdg = self.__render(model.winding,
-                                    'gen_' + model.winding['wire'].get('name'))
+                                   'gen_' + model.winding['wire'].get('name'))
         except:
             genwdg = self.__render(model, 'gen_winding')
 
@@ -514,11 +519,8 @@ 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'))
@@ -561,8 +563,6 @@ 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', {})
 
@@ -672,20 +672,14 @@ class Builder:
                         self.mesh_airgap(model) +
                         self.create_connect_models(model) +
                         self.create_rotor_winding(model))
-            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:
+            if 'statorRing' 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) +
@@ -696,7 +690,6 @@ class Builder:
                     self.create_connect_models(model) +
                     self.create_rotor_winding(model)) + \
                     self.create_thermal_properties(model)
-
         return (self.open_model(model) +
                 self.create_fe_losses(model) +
                 self.create_magnet(model, magnetMat))
@@ -757,6 +750,11 @@ class Builder:
                         if sim.get('airgap_induc', 0) else [])
         displ_stator_rotor = self.create_displ_stator_rotor(
             sim.get('eccentricity', {}))
+        # sliding band
+        sliding_band = []
+        if sim.get("sliding", 0):
+            sliding_band = [f'save_model("cont")',
+                            f'enable_sliding()']
         revert_displ = []
         if displ_stator_rotor:
             sim['eval_force'] = 1
@@ -776,6 +774,7 @@ class Builder:
                     sim.noload_ex_cur = sim.get('nload_ex_cur')
         felosses = custom_fefunc + self.create_fe_losses(sim)
         fslcalc = (displ_stator_rotor
+                   + sliding_band
                    + self.__render(sim, sim.get('calculationMode'))
                    + airgap_induc + revert_displ
                    + ['save_model("cont")'])
@@ -789,12 +788,6 @@ 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):
@@ -883,6 +876,7 @@ 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/isa7.py

@@ -1035,16 +1035,28 @@ class Isa7(object):
     def get_mass(self):
         """ return mass (in kg) of material conductors, iron, magnets
         """
+        masse_rotor_yoke = 0
+        section_rotor_yoke = 0
         try:
             return self.mass
         except AttributeError:
             self.mass = [{'iron': 0, 'conductors': 0, 'magnets': 0},
                          {'iron': 0, 'conductors': 0, 'magnets': 0}]
         scf = self.scale_factor()
+        for se in self.subregions:
+            if se.name == 'Bar':
+                r = 1 # as rotor bar is inside
+                spw = self.CU_SPEZ_WEIGHT*1e3
+                l = 1 #self.PS_LENGTH_CU[r]*1e-2
+                slf = 1 #self.PS_FILFACTOR_CU[r]
+                self.mass[r]['conductors'] += scf*se.area()*self.arm_length*spw*l*slf
         for se in self.superelements:
+            winding_detected=0
+            lamination_detected=0
             r = 0 if se.outside else 1
             if se.subregion:
                 if se.subregion.winding:
+                    winding_detected=1
                     spw = self.CU_SPEZ_WEIGHT*1e3
                     l = self.PS_LENGTH_CU[r]*1e-2
                     slf = self.PS_FILFACTOR_CU[r]
@@ -1052,6 +1064,7 @@ class Isa7(object):
                     continue
 
             if se.mcvtype or se.elements[0].is_lamination():
+                lamination_detected=1
                 try:
                     spw = self.iron_loss_coefficients[se.mcvtype-1][
                         'spec_weight']*1e3  # kg/m³
@@ -1062,6 +1075,9 @@ class Isa7(object):
                     fillfact = 1
                     #logger.warning('missing iron losscoeffs using defaults')
                 m = scf*self.arm_length*se.area()*spw*fillfact
+                if r == 1:
+                    masse_rotor_yoke += m
+                    section_rotor_yoke += se.area()
                 self.mass[r]['iron'] += m
             else:
                 try:

femagtools/job.py

@@ -146,6 +146,15 @@ class Task(object):
         result = dict(error=msg)
         return result
 
+    def read_nc(self):
+        "read most recent NC file and return result"
+        basedir = pathlib.Path(self.directory)
+        ncfiles = sorted(basedir.glob('*.nc'))
+        if not ncfiles:
+            return None
+        import femagtools.nc
+        return femagtools.nc.read(ncfiles[-1])
+
     def readErrorMessage(self, html=True):
         errstr = ""
         if html:

femagtools/machine/__init__.py

@@ -38,6 +38,7 @@ 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']
@@ -81,7 +82,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
                 losses=losses,
                 id=np.array(dqp['id'])/rwdg,
                 iq=np.array(dqp['iq'])/rwdg,
-                tcu1=temp[0],
+                tcu1=temp[0], tmag=temp[1],
                 **opts)
         else:
             beta = dqp['beta']
@@ -95,7 +96,7 @@ def create_from_eecpars(temp, eecpars, lfe=1, wdg=1):
                 losses=losses,
                 beta=beta,
                 i1=i1,
-                tcu1=temp[0],
+                tcu1=temp[0], tmag=temp[1],
                 **opts)
         return machine
 
@@ -113,40 +114,6 @@ 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)
 
@@ -179,7 +146,8 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             if 'ex_current' in bch.machine:
                 raise ValueError("not yet implemented for EESM")
             machine = PmRelMachinePsidq(m, p, psid, psiq, r1*rlfe*rwdg**2,
-                                        id, iq, ls*rwdg**2, losses=losses)
+                                        id, iq, ls*rwdg**2, losses=losses,
+                                        tmag=bch.magnet.get('Tmag', 20))
             try:
                 machine.rotor_mass = rlfe*np.sum(bch.weights[1])
             except (IndexError, AttributeError):
@@ -204,7 +172,8 @@ def create(bch, r1, ls, lfe=1, wdg=1):
             machine = PmRelMachineLdq(m, p, psid=psid, psiq=psiq,
                                       r1=r1*rlfe*rwdg**2,
                                       i1=i1, beta=beta, ls=ls*rwdg**2,
-                                      losses=losses)
+                                      losses=losses,
+                                      tmag=bch.magnet.get('Tmag', 20))
             try:
                 machine.rotor_mass = rlfe*np.sum(bch.weights[1])
             except (IndexError, AttributeError):

femagtools/machine/afpm.py

@@ -213,6 +213,9 @@ def parident(workdir, engine, temp, machine,
     if np.isscalar(machine['magnet'][slotmodel]['rel_magn_width']):
         num_slices = kwargs.get('num_slices', 3)
         rmagw = num_slices*[machine['magnet'][slotmodel]['rel_magn_width']]
+    elif len(machine['magnet'][slotmodel]['rel_magn_width']) == 1: 
+            num_slices = kwargs.get('num_slices', 3)
+            rmagw = num_slices*machine['magnet'][slotmodel]['rel_magn_width']
     else:
         rmagw = machine['magnet'][slotmodel]['rel_magn_width']
         num_slices = len(rmagw)
@@ -543,13 +546,18 @@ def process(lfe, pole_width, machine, bch):
         nsegx = machine['magnet'].get('num_segments', 1)
         if type(nsegx) == int:
             nsegx = [nsegx]*len(bch)
+        elif len(nsegx) == 1 and len(nsegx) < len(bch): 
+            nsegx = nsegx*len(bch)
+        else: 
+            pass 
         for nx, b in zip(nsegx, bch):
             pm = b['losses'][0]['magnet_data']
             magloss = ecloss.MagnLoss(magnet_data=[pm])
             ml = magloss.calc_losses_ialh2(nsegx=nx)
-            b['losses'][-1][k] = ml[0]
+            b["losses"][-1].update({k: ml[0]})
     else:
         k = 'magnetJ'
+
     if len(pole_width) > 1:
         maglosses = _integrate1d(radius, scale_factor*np.array(
             [b['losses'][-1][k]/lz
@@ -1025,7 +1033,9 @@ class AFPM:
                     machine['magnet'][slotmodel]['rel_magn_width'])
         if np.isscalar(machine['magnet'][slotmodel]['rel_magn_width']):
             rmagw = num_slices*[machine['magnet'][slotmodel]['rel_magn_width']]
-        else:
+        elif len(machine['magnet'][slotmodel]['rel_magn_width']) == 1: 
+                rmagw = num_slices*machine['magnet'][slotmodel]['rel_magn_width']
+        else: 
             rmagw = machine['magnet'][slotmodel]['rel_magn_width']
             num_slices = len(rmagw)
 

femagtools/machine/effloss.py

@@ -262,6 +262,9 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         nt = []
         if isinstance(m, (SynchronousMachineLdq, SynchronousMachinePsidq)):
             iq, id, iex = m.iqd_torque(T[-1])
+            i1max = betai1(iq, id)[1]
+            w1type, tmax = m.w1_imax_umax(i1max, u1) 
+            pmax = tmax*w1type/m.p
         else:
             iq, id = m.iqd_torque(T[-1])
 
@@ -270,12 +273,9 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         for nx in n:
             w1 = 2*np.pi*nx*m.p
             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)
+                tq = T[-1]
+                if tq*w1/m.p > pmax: 
+                    tq = pmax/w1*m.p
             else:
                 iq, id, tq =  m.iqd_imax_umax(i1max, w1, u1, T[-1],
                                             with_tmech=with_tmech,
@@ -289,7 +289,6 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
             raise ValueError("Speed, Torque Mesh is empty")
         nsamples = len(n)
         ntmesh = np.array(nt).T
-
     logger.info("total speed,torque samples %s", ntmesh.shape)
     if isinstance(m, (PmRelMachine, SynchronousMachine)):
         if num_proc > 1:
@@ -371,7 +370,7 @@ def efficiency_losses_map(eecpars, u1, T, temp, n, npoints=(60, 40),
         plfe1 = m.kpfe*m.iqd_plfe1(*iqd, f1)
         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 = m.iqd_plcu1(iqd[0], iqd[1], f1)
         try:
             plcu1_dc = m.iqd_plcu1(iqd[0], iqd[1],
                                 np.array([0.0 for i in f1])).tolist()