femagtools 1.5.7__py3-none-any.whl → 1.6.0__py3-none-any.whl

femagtools/machine/utils.py

@@ -303,11 +303,12 @@ def dqpar_interpol(xfit, dqpars, ipkey='temperature'):
         else:
             fpip[k] = ip.interp1d(
                 x, m, fill_value='extrapolate')(xfit).T
-    try:
-        for k in ('styoke_hyst', 'stteeth_hyst',
-                  'styoke_eddy', 'stteeth_eddy',
-                  'rotor_hyst', 'rotor_eddy',
-                  'magnet'):
+
+    for k in ('styoke_hyst', 'stteeth_hyst',
+              'styoke_eddy', 'stteeth_eddy',
+              'rotor_hyst', 'rotor_eddy',
+              'magnet'):
+        try:
             m = np.array([f['losses'][k] for f in sorted_dqpars]).T
             if len(x) > 2:
                 fpip['losses'][k] = np.array(
@@ -316,12 +317,13 @@ def dqpar_interpol(xfit, dqpars, ipkey='temperature'):
             else:
                 fpip['losses'][k] = ip.interp1d(
                     x, m, fill_value='extrapolate')(xfit).T
-            fpip['losses']['speed'] = dqpars[0]['losses']['speed']
-            for f in ('hf', 'ef'):
-                if f in dqpars[0]['losses']:
-                    fpip['losses'][f] = dqpars[0]['losses'][f]
-    except KeyError:
-        pass
+        except KeyError:
+            pass
+
+    fpip['losses']['speed'] = dqpars[0]['losses']['speed']
+    for f in ('hf', 'ef'):
+        if f in dqpars[0]['losses']:
+            fpip['losses'][f] = dqpars[0]['losses'][f]
     return x, fpip
 
 
@@ -351,52 +353,70 @@ def dqparident(workdir, engine, temp, machine,
     import pathlib
 
     wdgk = 'windings' if 'windings' in machine else 'winding'
-    da1 = machine['bore_diam']
-    Q1 = machine['stator']['num_slots']
+    def create_wdg(machine):
+        wpar = {'Q': machine['stator']['num_slots'],
+                'm': machine[wdgk]['num_phases'],
+                'p': machine['poles']//2}
+
+        if 'coil_span' in machine[wdgk]:
+            wpar['yd'] = machine[wdgk]['coil_span']
+        if 'num_layers' in machine[wdgk]:
+            wpar['l'] = machine[wdgk]['num_layers']
+
+        return windings.Winding(wpar)
+    try:
+        defspeed = 160/machine['poles']
+    except KeyError:
+        if kwargs.get('speed', 0) == 0:
+            raise ValueError('rated speed missing')
+        defspeed = kwargs['speed']
+
     lfe = machine['lfe']
     g = machine[wdgk].get('num_par_wdgs', 1)
-    slotmodel = [k for k in machine['stator'] if isinstance(
-        machine['stator'][k], dict)][-1]
-    if slotmodel == 'stator1':
-        hs = machine['stator']['stator1']['slot_rf1'] - \
-            machine['stator']['stator1']['tip_rh1']
-    else:
-        dy1 = machine['outer_diam']
-        hs = machine['stator'][slotmodel].get(
-            'slot_height', 0.6*(dy1-da1)/2)
-
     N = machine[wdgk]['num_wires']
-    Jmax = 20e6  # max current density in A/m2
-    f = machine[wdgk].get('fillfac', 0.42)
-    Acu = f*0.5*np.pi*(da1+hs)*hs
-    i1_max = round(Acu/Q1/N*Jmax/10)*10
+    if 'cufilfact' in machine[wdgk]:
+        fcu = machine[wdgk]['cufilfact']
+    elif 'fillfac' in machine[wdgk]:
+        fcu = machine[wdgk]['fillfac']
+    else:
+        fcu = 0.42
+
+    try: # calc basic dimensions if not fsl or dxf model
+        Q1 = machine['stator']['num_slots']
+        da1 = machine['bore_diam']
+        slotmodel = [k for k in machine['stator'] if isinstance(
+            machine['stator'][k], dict)][-1]
+        if slotmodel == 'stator1':
+            hs = machine['stator']['stator1']['slot_rf1'] - \
+                machine['stator']['stator1']['tip_rh1']
+        else:
+            dy1 = machine['outer_diam']
+            hs = machine['stator'][slotmodel].get(
+                'slot_height', 0.6*(dy1-da1)/2)
 
-    period_frac = kwargs.get('period_frac', 6)
-    if machine.get('external_rotor', False):
-        period_frac = 1  # TODO: missing femag support
+        Jmax = 30e6  # max current density in A/m2
+        Acu = fcu*0.5*np.pi*(da1+hs)*hs
+        i1_max = round(Acu/Q1/N*Jmax/10)*10
+    except KeyError:
+        if kwargs.get('i1_max', 0) == 0:
+            raise ValueError('i1_max missing')
+        i1_max = kwargs['i1_max']
 
     # winding resistance
-    wpar = {'Q': machine['stator']['num_slots'],
-            'm': machine[wdgk]['num_phases'],
-            'p': machine['poles']//2}
-
-    if 'coil_span' in machine[wdgk]:
-        wpar['yd'] = machine[wdgk]['coil_span']
-    if 'num_layers' in machine[wdgk]:
-        wpar['l'] = machine[wdgk]['num_layers']
-
-    wdg = windings.Winding(wpar)
-
-    if 'wire_gauge' in machine[wdgk]:
-        aw = machine[wdgk]['wire_gauge']
-    elif 'dia_wire' in machine[wdgk]:
-        aw = np.pi*machine[wdgk].get('dia_wire', 1e-3)**2/4
-    elif ('wire_width' in machine[wdgk]) and ('wire_height' in machine[wdgk]):
-        aw = machine['windings']['wire_width']*machine[wdgk]['wire_height']
-    else:  # wire diameter from slot area
-        aw = 0.75 * machine[wdgk].get('cufilfact', 0.45)*\
-            np.pi*da1*hs/Q1/wpar['l']/N
-    r1 = wdg_resistance(wdg, N, g, aw, da1, hs, lfe)
+    try:
+        wdg = create_wdg(machine)
+
+        if 'wire_gauge' in machine[wdgk]:
+            aw = machine[wdgk]['wire_gauge']
+        elif 'dia_wire' in machine[wdgk]:
+            aw = np.pi*machine[wdgk].get('dia_wire', 1e-3)**2/4
+        elif ('wire_width' in machine[wdgk]) and ('wire_height' in machine[wdgk]):
+            aw = machine['windings']['wire_width']*machine[wdgk]['wire_height']
+        else:  # wire diameter from slot area
+            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 = 0  # cannot calc winding resistance
 
     n = len(temp)
     parvardef = {
@@ -415,6 +435,10 @@ def dqparident(workdir, engine, temp, machine,
     leakfile = pathlib.Path(workdir) / 'end_wind_leak.dat'
     leakfile.unlink(missing_ok=True)
 
+    period_frac = kwargs.get('period_frac', 6)
+    if machine.get('external_rotor', False):
+        period_frac = 1  # TODO: missing femag support
+
     simulation = dict(
         calculationMode='ld_lq_fast',
         i1_max=kwargs.get('i1_max', i1_max),
@@ -426,12 +450,15 @@ def dqparident(workdir, engine, temp, machine,
         num_par_wdgs=machine[wdgk].get('num_par_wdgs', 1),
         num_cur_steps=kwargs.get('num_cur_steps', 5),
         num_beta_steps=kwargs.get('num_beta_steps', 7),
-        speed=kwargs.get('speed', 160/machine['poles']),
+        speed=kwargs.get('speed', defspeed),
         period_frac=period_frac)
 
     # TODO: cleanup()  # remove previously created files in workdir
     # start calculation
     results = parvar(parvardef, machine, simulation, engine)
+    if 'poles' not in machine:
+        machine['poles'] = 2*results['f'][0]['machine']['p']
+        da1 = 2*results['f'][0]['machine']['fc_radius']
     #import json
     #with open('results.json', 'w') as fp:
     #    json.dump(results, fp)
@@ -457,14 +484,25 @@ def dqparident(workdir, engine, temp, machine,
                            np.array(results['f'][i]['ldq'][k]))).tolist()
              for k in ('psid', 'psiq', 'torque', 'ld', 'lq', 'psim')})
         ldq.append(d)
-    losskeys = ('styoke_hyst', 'stteeth_hyst', 'styoke_eddy',
-                'stteeth_eddy', 'rotor_hyst', 'rotor_eddy',
-                'magnet')
+    # collect existing losses only
+    losskeymap = {'magnet': 'magnet'}
+    losskeys = [k for k in results['f'][0]['ldq']['losses']
+                if len(k.split('_')) > 1] + ['magnet']
+    for k in losskeys:
+        if k.find('_') > -1:
+            pref, post = k.split('_')
+            if pref.lower() == 'stza':
+                losskeymap[k] = 'stteeth_'+post
+            elif pref.lower() == 'stjo':
+                losskeymap[k] = 'styoke_'+post
+            else:
+                losskeymap[k] = k
     for i in range(0, len(results['f']), 2):
         j = i//2
         ldq[j]['temperature'] = results['x'][0][i]
-        ldq[j]['losses'] = {k: np.vstack((np.array(results['f'][i+1]['ldq']['losses'][k])[:-1, :],
-                                          np.array(results['f'][i]['ldq']['losses'][k]))).tolist()
+        ldq[j]['losses'] = {losskeymap[k]: np.vstack(
+            (np.array(results['f'][i+1]['ldq']['losses'][k])[:-1, :],
+             np.array(results['f'][i]['ldq']['losses'][k]))).tolist()
                             for k in losskeys}
         ldq[j]['losses']['speed'] = results['f'][i]['ldq']['losses']['speed']
         for k in ('hf', 'ef'):
@@ -473,10 +511,26 @@ def dqparident(workdir, engine, temp, machine,
     dqpars = {
         'm': machine[wdgk]['num_phases'],
         'p': machine['poles']//2,
-        'r1': machine[wdgk].get('resistance', r1),
         'ls1': ls1,
         "rotor_mass": rotor_mass, "kfric_b": 1,
         'ldq': ldq}
+    if 'resistance' in machine[wdgk]:
+        dqpars['r1'] = machine[wdgk]['resistance']
+    else:
+        if r1:
+            dqpars['r1'] = r1
+        else:
+            from .. import nc
+            model = nc.read(str(pathlib.Path(workdir) / machine['name']))
+            Q1 = model.num_slots
+            #machine['stator']['num_slots'] = Q1
+            wdg = create_wdg(machine)
+            istat = 0 if model.get_areas()[0]['slots'] else 1
+            asl = model.get_areas()[istat]['slots']
+            # diameter of wires
+            aw = fcu*asl/Q1/wdg.l/N
+            hs = asl/(np.pi*da1/3)
+            dqpars['r1'] = 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/mcv.py

@@ -50,6 +50,7 @@ transl = dict(
     rho='mc1_fe_spez_weigth',
     ch='mc1_ch_factor',
     cw='mc1_cw_factor',
+    ce='mc1_ce_factor',
     ch_freq='mc1_ch_freq_factor',
     cw_freq='mc1_cw_freq_factor',
     fillfac='mc1_fillfac',
@@ -58,6 +59,7 @@ transl = dict(
     bsat='mc1_bsat',
     Bo='mc1_base_induction',
     b_coeff='mc1_induction_factor',
+    b_beta_coeff='mc1_induction_beta_factor',
     fo='mc1_base_frequency',
     curve=[dict(
         hi='mc1_hi',
@@ -227,9 +229,12 @@ class Mcv(object):
         self.MC1_BASE_INDUCTION = 1.5
         self.MC1_CH_FACTOR = 0.0
         self.MC1_CW_FACTOR = 0.0
+        self.MC1_CE_FACTOR = 0.0
         self.MC1_CH_FREQ_FACTOR = 0.0
         self.MC1_CW_FREQ_FACTOR = 0.0
         self.MC1_INDUCTION_FACTOR = 0.0
+        self.MC1_INDUCTION_BETA_FACTOR = 0.0
+
         self.MC1_FE_SPEZ_WEIGTH = 7.65
         self.MC1_FE_SAT_MAGNETIZATION = 2.15
 
@@ -237,9 +242,11 @@ class Mcv(object):
         self.mc1_base_induction = self.MC1_BASE_INDUCTION
         self.mc1_ch_factor = self.MC1_CH_FACTOR
         self.mc1_cw_factor = self.MC1_CW_FACTOR
+        self.mc1_ce_factor = self.MC1_CE_FACTOR
         self.mc1_ch_freq_factor = self.MC1_CH_FREQ_FACTOR
         self.mc1_cw_freq_factor = self.MC1_CW_FREQ_FACTOR
         self.mc1_induction_factor = self.MC1_INDUCTION_FACTOR
+        self.mc1_induction_beta_factor = self.MC1_INDUCTION_BETA_FACTOR
         self.mc1_fe_spez_weigth = self.MC1_FE_SPEZ_WEIGTH
         self.mc1_fe_sat_magnetization = self.MC1_FE_SAT_MAGNETIZATION
 
@@ -519,6 +526,13 @@ class Writer(Mcv):
                          float(self.mc1_fe_sat_magnetization)])
 
         if not hasattr(self, 'losses') or not self.losses:
+            # new variables: ce factor for bertotti losses
+            # b_beta_coeff for modified steinmetz
+            try: 
+                self.writeBlock([float(self.mc1_ce_factor), 
+                                 float(self.mc1_induction_beta_factor)])
+            except: 
+                pass
             return
 
         try:
@@ -585,7 +599,7 @@ class Writer(Mcv):
             logger.info('Losses n freq %d n ind %d', nfreq, nind)
         except Exception as e:
             logger.error("Exception %s", e, exc_info=True)
-
+        
     def writeMcv(self, filename, fillfac=None, recsin=''):
         # windows needs this strip to remove '\r'
         filename = filename.strip()
@@ -857,6 +871,16 @@ class Reader(Mcv):
                 if not self.losses['f'] or not self.losses['pfe']:
                     self.losses = {}
 
+        self.ce = 0
+        self.b_beta_coeff = 0
+        try: 
+            if not self.losses['f'][0]:
+                self.fp.seek(-16, 1)
+            res = self.readBlock([float]*2)
+            self.ce, self.b_beta_coeff = res[0], res[1]
+        except:
+            pass
+
     def get_results(self):
         result = {
             'name': self.name,
@@ -873,6 +897,8 @@ class Reader(Mcv):
             'ch': self.ch,
             'ch_freq': self.ch_freq,
             'cw': self.cw,
+            'ce': self.ce,
+            'b_beta_coeff': self.b_beta_coeff,
             'cw_freq': self.cw_freq,
             'b_coeff': self.b_coeff,
             'rho': self.rho,

femagtools/model.py

@@ -379,6 +379,7 @@ class MachineModel(Model):
     def rotortype(self):
         """return type of rotor slot"""
         for k in self.rotor:
+            # anything that is a dict must represent the type
             if isinstance(self.rotor[k], dict):
                 return k
         raise AttributeError("Missing rotor model in {}".format(self.magnet))
@@ -386,8 +387,9 @@ class MachineModel(Model):
     def magnettype(self):
         """return type of magnet slot"""
         for k in self.magnet:
-            if k != 'material' and isinstance(self.magnet[k], dict):
-                return k
+            if k not in {'material', 'temp_prop'}:
+                if isinstance(self.magnet[k], dict):
+                    return k
         raise AttributeError("Missing magnet model in {}".format(self.magnet))
 
     def is_complete(self):

femagtools/nc.py

@@ -262,6 +262,7 @@ class Reader(object):
         ce_ind_exp = 1.5
         ke = 0.0
         khml = 0.65
+        cw_ind_beta_exp = 0
 
         lctype = ['magn_curve']*lmc + ['Outside', 'Inside']
         for i in range(lmc+2):
@@ -280,6 +281,11 @@ class Reader(object):
                 cw = float(mcgrp.variables['cw'][i].data)
                 cw_freq_exp = float(mcgrp.variables['cw_exp'][i].data)
                 cw_ind_exp = float(mcgrp.variables['ind_exp'][i].data)
+                try: 
+                    ce = float(mcgrp.variables['ce'][i].data)
+                    cw_ind_beta_exp = float(mcgrp.variables['ind_beta_exp'][i].data)
+                except: 
+                    pass
                 spec_weight = float(mcgrp.variables['spec_weight'][i].data)
                 fillfactor = float(mcgrp.variables['fillfac'][i].data)
                 shapefactor = 1.0
@@ -327,6 +333,7 @@ class Reader(object):
                 "cw_freq_exp": cw_freq_exp,
                 "cw_ind_exp": cw_ind_exp,
                 "ce": ce,
+                "cw_ind_beta_exp": cw_ind_beta_exp,
                 "ce_freq_exp": ce_freq_exp,
                 "ce_ind_exp": ce_ind_exp,
                 "ke": ke,

femagtools/opt.py

@@ -82,7 +82,7 @@ class Optimizer(object):
                 task.add_file(self.fea['pocfilename'],
                               self.fea['poc'].content())
             if 'stateofproblem' in self.fea:
-                task.set_stateofproblem(fea['stateofproblem'])
+                task.set_stateofproblem(self.fea['stateofproblem'])
         tstart = time.time()
         ntasks = engine.submit()
         status = engine.join()

femagtools/parstudy.py

@@ -181,10 +181,13 @@ class ParameterStudy(object):
         simulation['lfe'] = model.lfe
         simulation['move_action'] = model.move_action
         simulation['phi_start'] = 0.0
-        simulation['range_phi'] = 720/model.get('poles')
+        try:
+            simulation['range_phi'] = 720/model.get('poles')
+        except AttributeError: #  if dxf or pure fsl model
+            simulation['range_phi'] = 0.0
         simulation.update(model.winding)
         if 'pocfilename' not in simulation:
-            simulation['pocfilename'] = f"{model.name}_{model.poles}p.poc"
+            simulation['pocfilename'] = f"{model.name}.poc"
         fea = femagtools.model.FeaModel(simulation)
 
         prob = femagtools.moproblem.FemagMoProblem(decision_vars,

femagtools/plot/__init__.py

@@ -17,3 +17,4 @@ from .nc import spel, mesh, demag, demag_pos, \
 from .mcv import mcv_hbj, mcv_muer, felosses
 from .phasor import i1beta_phasor, iqd_phasor, phasor
 from .wdg import mmf, mmf_fft, zoneplan, winding_factors, winding
+from .fieldlines import fieldlines

femagtools/plot/bch.py

@@ -813,6 +813,7 @@ def main():
     ext = args.filename.split('.')[-1].upper()
     if ext.startswith('MC'):
         import femagtools.mcv
+        from femagtools.plot.mcv import mcv_hbj, mcv_muer
         mcv = femagtools.mcv.read(sys.argv[1])
 
         if mcv['mc1_type'] in (femagtools.mcv.MAGCRV, femagtools.mcv.ORIENT_CRV):
@@ -836,6 +837,7 @@ def main():
 
     if ext.startswith('PLT'):
         import femagtools.forcedens
+        from femagtools.plot.forcedens import forcedens, forcedens_fft
         fdens = femagtools.forcedens.read(args.filename)
         cols = 1
         rows = 2

femagtools/plot/fieldlines.py

@@ -0,0 +1,37 @@
+import re
+import xml.etree.ElementTree as ET
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib.lines as mpl
+
+rgbpat = re.compile('rgb\((\d+),(\d+),(\d+)\)')
+
+def fieldlines(svgfilename, ax=0):
+    """plot fieldlines from svg file"""
+    lines = []
+    cols = []
+    tree = ET.parse(svgfilename)
+    root = tree.getroot()
+    for line in root.findall('svg:line',
+                             {'svg': 'http://www.w3.org/2000/svg'}):
+        lines.append(
+            ((float(line.attrib['x1']), float(line.attrib['x2'])),
+             (float(line.attrib['y1']), float(line.attrib['y2']))))
+        cols.append(
+            [int(x)/256
+             for x in rgbpat.findall(line.attrib['stroke'])[0]])
+    a = np.array(lines)
+    xmax, xmin = np.max(a[:, 0]), np.min(a[:, 0])
+    ymax, ymin = np.max(a[:, 1]), np.min(a[:, 1])
+
+    if ax == 0:
+        ax = plt.gca()
+    ax.set_frame_on(False)
+    ax.set_aspect(1)
+    ax.set_xlim((xmin, xmax))
+    ax.set_ylim((ymax, ymin))  # upside down
+    ax.set_yticks([])
+    ax.set_xticks([])
+
+    for l, c in zip(lines, cols):
+        ax.add_line(mpl.Line2D(l[0], l[1], color=c))

femagtools/templates/basic_modpar.mako

@@ -88,6 +88,14 @@ m.pole_width      = ${model['pole_width']*1e3}
 % if hasattr(model, 'lfe'):
 m.arm_length      =   ${model.get(['lfe'])*1e3}
 % endif
+% if hasattr(model, 'lfe'):
+m.arm_length      =   ${model.get(['lfe'])*1e3}
+% endif
+% if hasattr(model, 'winding'):
+% if 'num_par_wdgs' in model.winding:
+m.num_par_wdgs    = ${model.winding['num_par_wdgs']}
+% endif
+% endif
 pre_models("basic_modpar")
 % endif
 % if hasattr(model, 'num_agnodes'):

femagtools/templates/bertotti.mako

@@ -0,0 +1,40 @@
+
+function pfe(Bx,By,kh,fnu,km,z,d)
+
+  -- Bx   flux density x component
+  -- By   flux density y component
+  -- kh   Hysterese Factor 
+  -- fnu  frequency
+  -- km   material factor
+  -- ph   return for hysterese losses
+  -- pw   return for eddy current losses
+  -- iret status 
+
+  -- Parameter
+
+  basfrq=${model['base_frequency']}      -- Base Frequency for ch and cw [Hz]
+  basind=${model['base_induction']}      -- Base Induction (Peak) [T]
+  ch=${model['ch']}                      -- Fe Hysteresis Coefficient ch [W/kg]
+  cw=${model['cw']}                      -- Fe Eddy Current Coefficient cw [W/kg]
+  ce=${model['ce']}                      -- Fe Excess Coefficient cw [W/kg]
+  hyscoef=${model['alpha']}              -- Hysteresis Frequency Coefficient
+  spweight= ${model['special_weight']}   -- Specific Weight Iron [gr/m3]
+  fillfact=${model['fillfac']}           -- Fillfactor Iron <= 1
+
+  -- Bertotti Iron Loss Model
+  -- pvfe = ch*f*(b**alpha) + cw*f**2*(b**2) + ce*f**1.5*(b**1.5)
+  hxx = Bx/fillfact                 -- Bx
+  hyy = By/fillfact                 -- By
+  b21 = math.sqrt(hxx*hxx+hyy*hyy)
+  b = b21/basind
+
+  hi = fnu/basfrq
+  hcw = hi^2
+  hce = hi^1.5
+
+  ph = kh*spweight*km*ch*hi*(b^hyscoef)   -- [W/m3]
+  pw = spweight*km*cw*hcw*(b^2)     -- [W/m3]
+  pe = spweight*km*ce*hce*(b^1.5)
+  iret=1
+  return ph, pw, pe, iret
+end

femagtools/templates/modified_steinmetz.mako

@@ -0,0 +1,39 @@
+
+function pfe(Bx,By,kh,fnu,km,z,d)
+
+  -- Bx   flux density x component
+  -- By   flux density y component
+  -- kh   Hysterese Factor 
+  -- fnu  frequency
+  -- km   material factor
+  -- ph   return for hysterese losses
+  -- pw   return for eddy current losses
+  -- iret status 
+
+  -- Parameter
+
+  basfrq=${model['base_frequency']}      -- Base Frequency for ch and cw [Hz]
+  basind=${model['base_induction']}      -- Base Induction (Peak) [T]
+  ch=${model['ch']}                      -- Fe Hysteresis Coefficient ch [W/kg]
+  cw=${model['cw']}                      -- Fe Eddy Current Coefficient cw [W/kg]
+  alpha=${model['alpha']}              -- Hysteresis Frequency Coefficient Alpha
+  beta=${model['beta']}              -- Hysteresis Frequency Coefficient Beta
+  spweight= ${model['special_weight']}   -- Specific Weight Iron [gr/m3]
+  fillfact=${model['fillfac']}           -- Fillfactor Iron <= 1
+
+  -- Modified Steinmetz Iron Loss Model
+  -- pvfe = ch*hi*(b**(alpha + beta*b)) + cw*(hi**2)*(b**2)
+  hxx = Bx/fillfact                 -- Bx
+  hyy = By/fillfact                 -- By
+  b21 = math.sqrt(hxx*hxx+hyy*hyy)
+
+  b = b21/basind
+  hi = fnu/basfrq
+  coeff = alpha+beta*b
+  ph = kh*spweight*km*ch*hi*(b^coeff)   -- [W/m3]
+  pw = spweight*km*cw*(b^2)*(hi^2)   -- [W/m3]
+  pe = 0.0
+
+  iret=1
+  return ph, pw, pe, iret
+end

femagtools/ts.py

@@ -292,7 +292,7 @@ class Losses(object):
             srname = srname+' '
 
         time = self.times.vector[-1]-self.times.vector[0]
-        return srlossenergy / time
+        return self.ohm_lossenergy_sr(self.nc.get_subregion(srname)) / time
 
     def ohm_lossenergy(self, start=0.0, end=0.0):
         '''Ohmic loss energy of all subregions

femagtools/utils.py

@@ -15,7 +15,13 @@ def fft(pos, y, pmod=0):
     if pmod:
         negative_periodic = pmod % 2
     else:
-        negative_periodic = np.abs(y[0] - y[-1])/np.max(y) > 1
+        #negative_periodic = np.abs(y[0] - y[-1])/np.max(y) > 1
+        # count zero crossings
+        ypos = np.asarray(y) > 0
+        nypos = ~ypos
+        nzc = len(((ypos[:-1] & nypos[1:])
+                   | (nypos[:-1] & ypos[1:])).nonzero()[0])
+        negative_periodic = nzc == 0 or nzc % 2 == 1
 
     if negative_periodic:
         yx = np.concatenate(

{femagtools-1.5.7.dist-info → femagtools-1.6.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: femagtools
-Version: 1.5.7
+Version: 1.6.0
 Summary: Python API for FEMAG
 Author-email: Ronald Tanner <tar@semafor.ch>, Dapu Zhang <dzhang@gtisoft.com>, Beat Holm <hob@semafor.ch>, Günther Amsler <amg@semafor.ch>, Nicolas Mauchle <mau@semafor.ch>
 License: Copyright (c) 2016-2023, Semafor Informatik & Energie AG, Basel