femagtools 1.7.8__py3-none-any.whl → 1.8.0__py3-none-any.whl

femagtools/fsl.py

@@ -95,12 +95,12 @@ class Builder:
         if templ in ('statorFsl', 'dxf'):
             self.fsl_stator = True
 
-        if templ != 'dxffile':
+        if templ not in ('dxffile', 'svgfile'):
             return
 
         from femagtools.dxfsl.converter import convert
         logger.info("Conv stator from %s",
-                    model.stator['dxffile']['name'])
+                    model.stator[templ]['name'])
         params = {}
         params['split'] = model.stator[templ].get('split', False)
         params['show_plots'] = model.stator[templ].get('plot', False)
@@ -109,7 +109,7 @@ class Builder:
         params['nodedist'] = model.stator.get('nodedist', 1)
         pos = 'in' if model.external_rotor else 'out'
         params['part'] = ('stator', pos)
-        conv = convert(model.stator['dxffile']['name'], **params)
+        conv = convert(model.stator[templ]['name'], **params)
 
         model.stator['num_slots'] = conv.get('tot_num_slot')
         model.set_value('poles', conv.get('num_poles'))
@@ -311,7 +311,7 @@ class Builder:
         if templ == 'dxf':
             # reuse dxfsl model
             self.fsl_rotor = True
-        if templ != 'dxffile':
+        if templ not in ('dxffile', 'svgfile'):
             return
 
         from femagtools.dxfsl.converter import convert
@@ -356,23 +356,18 @@ class Builder:
             if 'thcond' in model.stator:
                 fslcmds += [
                     '-- thermal properties in airgap',
-                    'if m.zeroangl ~= nil then',
-                    '   ag_cond = 0.063',
-                    '   thcap = 1007',
-                    '   beta = math.pi*m.npols_gen/m.num_poles + m.zeroangl/180*math.pi',
-                    '   xai, yai = pr2c((da1+da2)/4, beta)',
-                    '   def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
-                    '   xai, yai = pr2c((da1+da2)/4-ag/4, beta)',
-                    '   def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
-                    '   xai, yai = pr2c((da1+da2)/4+ag/4, beta)',
-                    '   def_mat_therm(xai,yai,"cyan",1.19,ag_cond,thcap,1)',
+                    'if m.zeroangl == nil then',
+                    '   m.zeroangl = 0.0',
+                    'end',
+                    'beta = math.pi*m.npols_gen/m.num_poles + m.zeroangl/180*math.pi',
                     '',
-                    '   state_of_problem("therm_static") -- thermic boundary conditions',
-                    '   x1,y1 = pd2c(dy2/2,m.zeroangl)',
-                    '   x2,y2 = pd2c(dy1/2,m.zeroangl)',
-                    '   beta = 360*m.npols_gen/m.num_poles',
-                    '   x3,y3 = pd2c(dy1/2,beta+m.zeroangl)',
-                    '   x4,y4 = pd2c(dy2/2,beta+m.zeroangl)',
+                    'state_of_problem("therm_static") -- thermic boundary conditions',
+                    'x1,y1 = pd2c(dy2/2,m.zeroangl)',
+                    'x2,y2 = pd2c(dy1/2,m.zeroangl)',
+                    'beta = 360*m.npols_gen/m.num_poles',
+                    'x3,y3 = pd2c(dy1/2,beta+m.zeroangl)',
+                    'x4,y4 = pd2c(dy2/2,beta+m.zeroangl)',
+                    'if m.b_min == 0 then',
                     '   def_bcond_tp(x1,y1,x2,y2,x3,y3,x4,y4, 4)',
                     'end',
                     'state_of_problem("mag_static")']
@@ -441,13 +436,13 @@ class Builder:
 
     def create_gen_winding(self, model):
         try:
-            if model.winding['wire']['name'] == 'hairpin_winding':
-                model.winding['wire'].update(
-                    {"num_layers": model.winding["num_layers"]})
-                genwdg = self.__render(model.winding,
-                                       'gen_' + model.winding['wire'].get('name'))
-        except KeyError:  # not hairpin_winding
+            model.winding['wire'].update(
+                {"num_layers": model.winding["num_layers"]})
+            genwdg = self.__render(model.winding,
+                                    'gen_' + model.winding['wire'].get('name'))
+        except:
             genwdg = self.__render(model, 'gen_winding')
+
         k = list({'leak_dist_wind',
                   'leak_evol_wind',
                   'leak_tooth_wind'}.intersection(model.winding))
@@ -474,30 +469,31 @@ class Builder:
                      'file_leak:close()'])
         return genwdg
 
-    def prepare_model_with_dxf(self, model):
+    def prepare_model_with_dxf_or_svg(self, model):
         from femagtools.dxfsl.converter import convert
-        dxfname = model.dxffile.get('name', None)
-        if not dxfname:
-            logger.error('Name of dxf-file expected')
+        fmt = model.dxffile if hasattr(model, 'dxffile') else model.svgfile
+        fname = fmt.get('name', None)
+        if not fname:
+            logger.error('Name of dxf or svg file expected')
             return []
 
-        if dxfname.split('.')[-1] not in ('dxf', 'svg'):  # add svg support
-            dxfname += '.dxf'
-        if not os.path.isfile(dxfname):
-            logger.error('File "%s" not found', dxfname)
-            raise ValueError(f'File {dxfname} not found')
+        if fname.split('.')[-1] not in ('dxf', 'svg'):  # add svg support
+            fname += fmt[:3]
+        if not os.path.isfile(fname):
+            logger.error('File "%s" not found', fname)
+            raise ValueError(f'File {fname} not found')
 
         params = {}
-        params['split'] = model.dxffile.get('split', False)
-        params['show_plots'] = model.dxffile.get('plot', False)
+        params['split'] = fmt.get('split', False)
+        params['show_plots'] = fmt.get('plot', False)
         params['write_fsl'] = True
-        params['airgap'] = model.dxffile.get('airgap', 0.0)
-        params['nodedist'] = model.dxffile.get('nodedist', 1)
-        params['full_model'] = model.dxffile.get('full_model', False)
-        params['EESM'] = model.dxffile.get('type', 'PMSM') == 'EESM'
+        params['airgap'] = fmt.get('airgap', 0.0)
+        params['nodedist'] = fmt.get('nodedist', 1)
+        params['full_model'] = fmt.get('full_model', False)
+        params['EESM'] = fmt.get('type', 'PMSM') == 'EESM'
         if params['EESM']:
             model.rotor['EESM'] = {}
-        conv = convert(dxfname, **params)
+        conv = convert(fname, **params)
 
         model.set_value('poles', conv.get('num_poles'))
         model.set_value('outer_diam', conv.get('dy1') * 1e-3)
@@ -510,6 +506,9 @@ class Builder:
             setattr(model, 'stator', {})
         model.stator['num_slots'] = conv.get('tot_num_slot')
         model.stator['slot_area'] = conv.get('slot_area')
+        model.stator['dy1'] = conv.get('dy1')*1e-3
+        model.stator['dy2'] = conv.get('dy2')*1e-3
+
         if model.get('num_agnodes', 0) == 0:
             model.set_value('agndst', conv['agndst']*1e-3)
             logger.info("num poles %d num slots %d outer diameter %.4f m agndst %.4f mm",
@@ -526,19 +525,39 @@ class Builder:
 
         if 'fsl_stator' in conv:
             self.fsl_stator = True
-            model.stator['dxf'] = dict(fsl=conv['fsl_stator'])
+            th_props = [' ']
+            if model.stator.get('thcond', 0):
+                th_props = [f'stator_density = {model.stator["density"]}',
+                            f'stator_thcond = {model.stator["thcond"]}',
+                            f'stator_thcap = {model.stator["thcap"]}',
+                            ]
+            model.stator['dxf'] = dict(fsl=conv['fsl_stator'] + th_props)
         if not (hasattr(model, 'magnet') or hasattr(model, 'rotor')):
             if params['EESM']:
                 setattr(model, 'rotor', {})
             else:
                 setattr(model, 'magnet', {})
+
         if 'fsl_rotor' in conv:
             self.fsl_rotor = True
+            th_props = ['']
+            logger.info(model['magnet'])
             if hasattr(model, 'magnet'):
-                model.magnet['dxf'] = dict(fsl=conv['fsl_rotor'])
+                if model['magnet'].get('thcond', 0):
+                    th_props = [f'rotor_density = {model["magnet"]["density"]}',
+                                f'rotor_thcond = {model["magnet"]["thcond"]}',
+                                f'rotor_thcap = {model["magnet"]["thcap"]}'
+                                ]
+                model.magnet['dxf'] = dict(fsl=conv['fsl_rotor'] + th_props)
             if hasattr(model, 'rotor'):
                 model.rotor['dxf'] = dict(fsl=conv['fsl_rotor'])
 
+    def create_thermal_properties(self, model):
+        if model.stator.get('thcond') and model.stator.get('thcap') and \
+            model.stator.get('density'):
+            return self.__render(model, 'prepare_thermal')
+        return ['']
+
     def create_model(self, model, magnets=[], condMat=[], ignore_material=False):
         magnetMat = {}
         material = ''
@@ -559,8 +578,8 @@ class Builder:
                 magnetMat['magntemp'] = 20
         if model.is_complete():
             logger.info("create new model '%s'", model.name)
-            if model.is_dxffile():
-                self.prepare_model_with_dxf(model)
+            if model.is_dxffile() or model.is_svgfile():
+                self.prepare_model_with_dxf_or_svg(model)
             else:
                 self.prepare_stator(model)
                 if hasattr(model, 'magnet'):
@@ -594,6 +613,13 @@ class Builder:
                          self.create_magnet_model(model))
                 if magnetMat:
                     rotor += self.create_magnet(model, magnetMat)
+
+                if model['magnet'].get('thcond_magnet', 0):
+                    th_props = [f'magn_density = {1e3*model["magnet"]["spmaweight_magnet"]}',
+                                f'magn_thcond = {model["magnet"]["thcond_magnet"]}',
+                                f'magn_thcap = {model["magnet"]["thcap_magnet"]}'
+                                ]
+                    rotor += th_props
             else:
                 rotor = self.create_rotor_model(
                     model, condMat, ignore_material)
@@ -635,7 +661,8 @@ class Builder:
                     rotor +
                     self.mesh_airgap(model) +
                     self.create_connect_models(model) +
-                    self.create_rotor_winding(model))
+                    self.create_rotor_winding(model)) + \
+                    self.create_thermal_properties(model)
 
         return (self.open_model(model) +
                 self.create_fe_losses(model) +

femagtools/isa7.py

@@ -544,6 +544,10 @@ class Isa7(object):
              16: [0.8274509803921568, 0.8274509803921568, 0.8274509803921568]} # LIGHGREY
 
     def __init__(self, reader):
+        try:
+            self.state_of_problem = reader.state_of_problem
+        except:
+            pass
         self.points = [Point(x, y)
                        for x, y in zip(reader.POINT_ISA_POINT_REC_PT_CO_X,
                                        reader.POINT_ISA_POINT_REC_PT_CO_Y)]
@@ -1139,6 +1143,43 @@ class Isa7(object):
                 sreg[sr.name] = [0,0,0]
         return sreg
 
+    def get_minmax_temp(self):
+        def node_subregion(subregion_name):
+            node_temperature = []
+            for i in self.subregions:
+                if i.name.lower() == subregion_name:
+                    for j in i.elements():
+                        for k in j.vertices:
+                            node_temperature.append(k.vpot[-1])
+            ndtemp = np.unique(node_temperature)
+            return [np.amax(ndtemp), np.amin(ndtemp), np.mean(ndtemp)]
+
+        zero_temp = [0.0, 0.0, 0.0]
+        component_temperature = dict(styoke=zero_temp, stteeth=zero_temp,
+                                     magnet=zero_temp, winding=zero_temp)
+        for i in self.subregions:
+            if i.name:
+                sreg_name = i.name.lower()
+                if sreg_name in ('stza', 'stth', 'stteeth'):
+                    component_temperature['stteeth'] = node_subregion(sreg_name)
+                elif sreg_name in ('styk', 'styoke', 'stjo'):
+                    component_temperature['styoke'] = node_subregion(sreg_name)
+                elif sreg_name == 'iron':
+                    component_temperature['iron'] = node_subregion(sreg_name)
+                elif sreg_name == 'pmag':
+                    component_temperature['magnet'] = node_subregion(sreg_name)
+                else:
+                    pass
+
+        wdg_temps = []
+        for j in self.wdg_elements():
+            for k in j.vertices:
+                wdg_temps.append(k.vpot[-1])
+        wdg_temp = np.unique(wdg_temps)
+        component_temperature['winding'] = [np.amax(wdg_temp),
+                                            np.amin(wdg_temp),
+                                            np.mean(wdg_temp)]
+        return component_temperature
 
     def flux_dens(self, x, y, icur, ibeta):
         el = self.get_element(x, y)

femagtools/job.py

@@ -112,7 +112,7 @@ class Task(object):
         if bchfile_list:
             result = femagtools.bch.Reader()
             with open(bchfile_list[-1]) as f:
-                logger.info("Reading %s",
+                logger.debug("Reading %s",
                             bchfile_list[-1])
                 result.read(f)
             if bagdat.exists():
@@ -127,7 +127,7 @@ class Task(object):
             asm_list = sorted(basedir.glob(
                 '*_[0-9][0-9][0-9].ASM'))
             if asm_list:
-                logger.info("Reading %s",
+                logger.debug("Reading %s",
                             asm_list[-1])
                 result = femagtools.asm.read(asm_list[-1])
                 if bagdat.exists():

femagtools/machine/afpm.py

@@ -645,6 +645,9 @@ class AFPM:
                 parameters={
                     'phi_voltage_winding': current_angles})
             logger.info("Current angles: %s", current_angles)
+        elif (simulation['calculationMode'] == 'cogg_calc' and
+            'poc' not in simulation):
+            simulation['poc'] = poc.Poc(machine['pole_width'])
 
         lresults = self.parstudy(
             parvardef,
@@ -652,5 +655,6 @@ class AFPM:
             simulation, engine)  # Note: imcomplete machine prevents rebuild
 
         results = process(lfe, pole_width, machine, lresults['f'])
-        results.update(_psidq_ldq(results, nlresults))
+        if nlresults:
+            results.update(_psidq_ldq(results, nlresults))
         return results

femagtools/machine/pm.py

@@ -148,7 +148,7 @@ class PmRelMachine(object):
             kr = self.zeta1[0]*freq**3 + self.zeta1[1]*freq**2 + \
                 self.zeta1[2]*freq + self.zeta1[3]
             kr[kr<1] = 1.
-            return self.r1*(1 - self.kth1*(self.tcu1 - 20))*kr  # ref 20°C
+            return self.r1*(1 + self.kth1*(self.tcu1 - 20))*kr  # ref 20°C
         if self.skin_resistance is not None:
             return self.skin_resistance(self.r1, w, self.tcu1, kth=self.kth1)
 

femagtools/machine/sm.py

@@ -339,6 +339,20 @@ class SynchronousMachine(object):
 
     def rstat(self, w):
         """stator resistance"""
+        if isinstance(self.zeta1, list):
+            # polyfit from ac loss calculation
+            freq = w/2/np.pi
+            kr = self.zeta1[0]*freq**3 + self.zeta1[1]*freq**2 + \
+                self.zeta1[2]*freq + self.zeta1[3]
+            if isinstance(kr, list): 
+                kr = np.array(kr)
+                kr[kr<1.0] = 1.0
+            elif isinstance(kr, np.ndarray):
+                kr[kr<1.0] = 1.0
+            else: 
+                if kr < 1.0: 
+                    kr = 1.0
+            return self.r1*(1 + self.kth1*(self.tcu1 - 20))*kr  # ref 20°C
         sr = self.skin_resistance[0]
         if sr is not None:
             return sr(self.r1, w, self.tcu1, kth=self.kth1)

femagtools/machine/utils.py

@@ -411,6 +411,7 @@ def dqparident(workdir, engine, temp, machine,
         elif ('wire_width' in machine[wdgk]) and ('wire_height' in machine[wdgk]):
             aw = machine[wdgk]['wire_width']*machine[wdgk]['wire_height']
         else:  # wire diameter from slot area
+            da1 = machine['bore_diam']
             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):
@@ -489,6 +490,8 @@ def dqparident(workdir, engine, temp, machine,
         machine['poles'] = 2*results['f'][0]['machine']['p']
         da1 = 2*results['f'][0]['machine']['fc_radius']
         wdg = create_wdg(machine)
+    if 'bore_diam' in machine:
+        da1 = machine['bore_diam']
     ls1 = 0
     try:
         leakages = [float(x)
@@ -569,14 +572,12 @@ def dqparident(workdir, engine, temp, machine,
         if r1:
             dqpars['r1'] = r1
         else:
-            from .. import nc
-            model = nc.read(str(pathlib.Path(workdir) / machine['name']))
+            model = parvar.femag.read_nc()
             try:
                 nlayers = wdg.l
             except UnboundLocalError:
                 wdg = create_wdg(machine)
                 nlayers = wdg.l
-                da1 = machine['outer_diam']
             Q1 = wdg.Q
             istat = 0 if model.get_areas()[0]['slots'] else 1
             asl = model.get_areas()[istat]['slots']