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

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.0'
+__version__ = '1.8.1'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2024 Gamma Technology'

femagtools/dxfsl/area.py

@@ -822,9 +822,9 @@ class Area(object):
             mm[3] = max(mm[3], n[3])
         return mm
 
-    def intersect_line(self, line):
+    def intersect_area(self, line):
         for e in self.area:
-            if e.intersect_line(line):
+            if e.intersect_shape(line, include_end=True):
                 return True
         return False
 

femagtools/dxfsl/conv.py

@@ -250,11 +250,6 @@ def main():
     keys = ('tot_num_slot', 'num_sl_gen', 'num_poles', 'nodedist',
             'dy1', 'da1', 'da2', 'dy2', 'agndst', 'name')
     logger.info("%s", {k: res[k] for k in keys if k in res})
-    if args.write_fsl:
-        if res is not None:
-            basename = os.path.basename(args.dxfile).split('.')[0]
-            with io.open(basename + '.fsl', 'w', encoding='utf-8') as f:
-                f.write('\n'.join(res['fsl']))
 
 if __name__ == "__main__":
     loglevel = logging.INFO

femagtools/dxfsl/converter.py

@@ -2,6 +2,7 @@
 
 """
 import os
+import io
 from pathlib import Path
 from femagtools import __version__
 from femagtools.dxfsl.geom import Geometry
@@ -160,12 +161,16 @@ def symmetry_search(machine,
 
 
 def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
+    global journal
     logger.debug("Begin of build_machine_rotor")
+
     if machine.has_windings():
         logger.debug("do nothing here with windings in rotor")
         logger.debug("End of build_machine_rotor")
         return machine
 
+    timer = Timer(start_it=True)
+
     if machine.is_mirrored():
         logger.debug("Rotor is mirrored")
         machine_temp = machine.undo_mirror()
@@ -207,17 +212,27 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
         machine_temp.create_inner_corner_areas()
 
     if not machine_temp.is_mirrored():
-        machine_temp.create_boundery_nodes()
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Rotor before Boundery Corr")
+        machine_temp.create_boundary_nodes()
 
     plot_geom(False,  # for developer
               plt, machine_temp.geom,
               title="Final Rotor")
+
+    t = timer.stop("-- rotor created in %0.4f seconds --")
+    journal.put('time_rotor_created', t)
+
     logger.debug("End of build_machine_rotor")
     return machine_temp
 
 
 def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False):
+    global journal
     logger.debug("Begin of build_machine_stator")
+    timer = Timer(start_it=True)
+
     if not machine.geom.is_stator():
         logger.debug("Rotor with windings")
 
@@ -240,25 +255,34 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
     else:
         machine_temp = machine
 
-    rebuild = machine_temp.create_auxiliary_lines()
     if machine_temp.geom.reduce_element_nodes(mindist):
+        machine_temp.rebuild_subregions(EESM, single=single)
         plot_geom(False,  # for developer
                   plt, machine_temp.geom,
-                  title="Nodes reduced",
-                  areas=False)
-        rebuild = True
-    if rebuild:
+                  title="Nodes reduced")
+
+    if machine_temp.create_auxiliary_lines():
         machine_temp.rebuild_subregions(EESM, single=single)
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Stator with Auxiliary Lines")
 
     if inner:
         machine_temp.create_inner_corner_areas()
 
     if not machine_temp.is_mirrored():
-        machine_temp.create_boundery_nodes()
+        plot_geom(False,  # for developer
+                  plt, machine_temp.geom,
+                  title="Stator before Boundery Corr")
+        machine_temp.create_boundary_nodes()
 
     plot_geom(False,  # for developer
               plt, machine_temp.geom,
               title="Final Stator")
+
+    t = timer.stop("-- stator created in %0.4f seconds --")
+    journal.put('time_stator_created', t)
+
     logger.debug("End of build_machine_stator")
     return machine_temp
 
@@ -290,6 +314,7 @@ def convert(dxfile,
             full_model=False,
             debug_mode=False,
             write_journal=False):
+    global journal
     layers = ()
     conv = {}
 
@@ -816,10 +841,19 @@ def convert(dxfile,
 
             mtype = 'EESM' if EESM else 'PMSM'
             fslrenderer = FslRenderer(basename, mtype)
-            conv['fsl'] = fslrenderer.render(machine, inner, outer)
+            conv['fsl'] = fslrenderer.render(machine, inner, outer, standalone=True)
 
     if params is not None:
         conv.update(params)
+
+    if write_fsl:
+        logger.debug("Write fsl")
+        if conv and conv['fsl']:
+            with io.open(basename + '.fsl', 'w', encoding='utf-8') as f:
+                f.write('\n'.join(conv['fsl']))
+        else:
+            logger.warning("No fsl data available")
+
     conv['name'] = basename
     t = timer.stop("-- all done in %0.4f seconds --", info=True)
     journal.put('time_total', t)

femagtools/dxfsl/fslrenderer.py

@@ -154,7 +154,7 @@ class FslRenderer(object):
         return sorted([(abs(r - np.linalg.norm(e.center_of_connection())), e)
                        for e in geom.elements(Shape)])
 
-    def render(self, machine, inner=False, outer=False):
+    def render(self, machine, inner=False, outer=False, standalone=False):
         '''create fsl statements with nodechains'''
         machine.set_alfa_and_corners()
         geom = machine.geom
@@ -162,6 +162,14 @@ class FslRenderer(object):
         geom.split_all_lines_longer_than(split_len)
         self.content = []
 
+        if standalone:
+            self.content += ['if (agndst == nil) then',
+                             '  agndst = 0.5',
+                             '  m.npols_gen = 2',
+                             '  m.num_sl_gen = 2',
+                             '  new_model_force("{}","Test")'.format(self.model),
+                             'end']
+
         MAXDST=4.0
         NUMLEVELS=10
         NDT0=1.1

femagtools/dxfsl/geom.py

@@ -2753,7 +2753,7 @@ class Geometry(object):
             intersection = False
             inner_gap_list = []
             for no_a in my_notouch:
-                if no_a.intersect_line(line):
+                if no_a.intersect_area(line):
                     intersection = True
                     logger.debug("   --> intersection with %s",
                                  no_a.get_id())
@@ -2817,6 +2817,7 @@ class Geometry(object):
                 pts = self.split_and_get_intersect_points(line)
                 if len(pts) != 2:
                     logger.error("ERROR in create_aux_lines()")
+                    self.journal.put("warning", "Error while creating auxiliary lines")
                     logger.debug("Points: %s", pts)
                     logger.debug("Line: %s", line)
 
@@ -3635,16 +3636,21 @@ class Geometry(object):
             area.mark_airgap_corners(start_cp, end_cp)
         return
 
-    def num_areas_of_type(self, type):
+    def num_areas_of_type(self, types=()):
         return len([area for area in self.list_of_areas()
-                    if area.is_type(type)])
+                    if area.type in types])
 
     def area_size_of_type(self, type):
         return sum([area.surface for area in self.list_of_areas()
                     if area.is_type(type)])*1e-3
 
     def num_of_windings(self):
-        return self.num_areas_of_type(AREA.TYPE_WINDINGS)
+        return self.num_areas_of_type((AREA.TYPE_WINDINGS,))
+
+    def num_of_irons(self):
+        return self.num_areas_of_type((AREA.TYPE_IRON,
+                                       AREA.TYPE_YOKE,
+                                       AREA.TYPE_TOOTH,))
 
     def area_close_to_endangle(self, type):
         return len([area for area in self.list_of_areas()
@@ -4206,9 +4212,9 @@ class Geometry(object):
         if not ok1:  # fatal => ignore
             logger.debug("end repair_border_line: missing point %s", n1)
             return False
-        d1, n1, ok1 = nodes[-1]
-        if not ok1:  # fatal => ignore
-            logger.debug("end repair_border_line: missing point %s", n1)
+        d2, n2, ok2 = nodes[-1]
+        if not ok2:  # fatal => ignore
+            logger.debug("end repair_border_line: missing point %s", n2)
             return False
 
         remove_n1 = None
@@ -4240,89 +4246,132 @@ class Geometry(object):
         logger.debug("end repair_border_line")
         return True
 
-    def create_boundery_nodes(self,
+    def create_boundary_nodes(self,
                               center,
                               startangle,
                               endangle,
                               rtol=None, atol=None):
+        logger.debug("begin of create_boundary_nodes")
         if not rtol:
-            rtol = 1e-4
+            rtol = 1e-3
         if not atol:
             atol = 1e-3
 
-        start_nodes = [n for n in self.angle_nodes(center, startangle, rtol, atol)]
-        end_nodes = [n for n in self.angle_nodes(center, endangle, rtol, atol)]
-        alpha = alpha_angle(startangle, endangle)
-
-        logger.debug("begin of create_boundery_nodes")
-        start_rot_nodes = self.rotate_nodes(alpha, start_nodes)
-        end_rot_nodes = self.rotate_nodes(-alpha, end_nodes)
-
-        def miss_nodelist(src_nodelist, dest_nodelist):
-            nlist = []
-            for src_n in src_nodelist:
-                ok = False
-                for dest_n in dest_nodelist:
-                    if points_are_close(src_n, dest_n, rtol=rtol, atol=atol):
-                        ok = True
-                        break
-                if not ok:
-                    nlist.append(src_n)
-            return nlist
-
-        logger.debug("Begin with Nodes Start=%s,  End=%s", len(start_nodes), len(end_nodes))
-
-        missing_end_nodes = miss_nodelist(start_rot_nodes, end_nodes)
-        missing_start_nodes = miss_nodelist(end_rot_nodes, start_nodes)
-
-        if missing_start_nodes:
-            logger.debug("%s missing start nodes", len(missing_start_nodes))
-            start_nodes = [(distance(center, n), n, True) for n in start_nodes]
-            for n in missing_start_nodes:
-                start_nodes.append((distance(center, n), n, False))
-            start_nodes.sort()
-            if not self.repair_border_line(start_nodes):
-                logger.debug("end of create_boundery_nodes (failed)")
-                return
-        else:
-            start_nodes = [(distance(center, n), n, True) for n in start_nodes]
-            start_nodes.sort()
-
-        if missing_end_nodes:
-            logger.debug("%s missing end nodes", len(missing_end_nodes))
-            end_nodes = [(distance(center, n), n, True) for n in end_nodes]
-            for n in missing_end_nodes:
-                end_nodes.append((distance(center, n), n, False))
-            end_nodes.sort()
-            if not self.repair_border_line(end_nodes):
-                logger.debug("end of create_boundery_nodes (failed)")
-                return
-        else:
-            end_nodes = [(distance(center, n), n, True) for n in end_nodes]
-            end_nodes.sort()
+        def check_line(nlist):
+            d, n1, b = nlist[0]
+            for d, n2, b in nlist[1:]:
+                if not self.get_edge_element(n1, n2):
+                    return False
+                n1 = n2
+            return True
 
-        start_nodes = [(distance(center, n), n)
+        start_nodes = [(distance(center, n), n, True)
                        for n in self.angle_nodes(center, startangle, rtol, atol)]
         start_nodes.sort()
-        end_nodes = [(distance(center, n), n)
+        d_start1, n, b = start_nodes[0]
+        if not points_are_close(self.start_corners[0], n):
+            logger.warning("end of create_boundary_nodes: corner missing in start boundary")
+            return False
+        d_start2, n, b = start_nodes[-1]
+        if not points_are_close(self.start_corners[-1], n):
+            logger.warning("end of create_boundary_nodes: corner missing in start boundary")
+            return False
+        if not check_line(start_nodes):
+            logger.warning("end of create_boundary_nodes: bad start boundary")
+            return False
+
+        logger.debug("Start Nodes")
+        [logger.debug(" --> %s", x) for x in start_nodes]
+
+        end_nodes = [(distance(center, n), n, True)
                      for n in self.angle_nodes(center, endangle, rtol, atol)]
         end_nodes.sort()
+        d_end1, n, b = end_nodes[0]
+        if not points_are_close(self.end_corners[0], n):
+            logger.warning("end of create_boundary_nodes: corner missing in end boundary")
+            return False
+        d_end2, n, b = end_nodes[-1]
+        if not points_are_close(self.end_corners[-1], n):
+            logger.warning("end of create_boundary_nodes: corner missing in end boundary")
+            return False
+        if not check_line(end_nodes):
+            logger.warning("end of create_boundary_nodes: bad end boundary")
+            return False
+
+        logger.debug("End Nodes")
+        [logger.debug(" --> %s", x) for x in end_nodes]
 
-        logger.debug("End with Nodes Start=%s,  End=%s", len(start_nodes), len(end_nodes))
+        logger.debug("Lower Corners: %s <> %s", d_start1, d_end1)
+        if not np.isclose(d_start1, d_end1, rtol=self.rtol, atol=self.atol):
+            logger.warning("end of create_boundary_nodes: corners dont match")
+            return False
 
-        nodes = [n for d, n in start_nodes]
-        start_rot_nodes = self.rotate_nodes(alpha, nodes)
+        logger.debug("Upper Corners: %s <> %s", d_start2, d_end2)
+        if not np.isclose(d_start2, d_end2, rtol=self.rtol, atol=self.atol):
+            logger.warning("end of create_boundary_nodes: corners dont match")
+            return False
 
-        for d, node in start_nodes:
-            self.set_point_of_node(node, node)
-        i = 0
-        if len(end_nodes) == len(start_rot_nodes):
-            for d, node in end_nodes:
-                self.set_point_of_node(node, start_rot_nodes[i])
-                i += 1
+        if len(start_nodes) == 2 and len(end_nodes) == 2:
+            logger.debug("end of create_boundary_nodes: only corners available")
+            return False  # ok
+
+        def node_distance_list(nodelist1, nodelist2):
+            distlist = []
+            i1 = 0
+            i2 = 0
+            while i1 < len(nodelist1) and i2 < len(nodelist2):
+                d1, n1, b1 = nodelist1[i1]
+                d2, n2, b2 = nodelist2[i2]
+                if np.isclose(d1, d2, rtol=self.rtol, atol=self.atol):
+                    distlist.append((d1, True, True))
+                    i1 += 1
+                    i2 += 1
+                elif d1 > d2:
+                    distlist.append((d2, False, True))
+                    i2 += 1
+                else:
+                    distlist.append((d1, True, False))
+                    i1 += 1
+            if not i1 == len(nodelist1) and i2 == len(nodelist2):
+                return []
+            return distlist
 
-        logger.debug("end of create_boundery_nodes")
-        return
+        distance_list = node_distance_list(start_nodes, end_nodes)
+        [logger.debug("distance: %s, (%s, %s)", d, b1, b2)
+         for d, b1, b2 in distance_list]
+
+        diff = len(distance_list) - len(start_nodes)
+        done = False
+        if not diff == 0:
+            logger.debug("%s missing start nodes", diff)
+            done = True
+            for d, in_start, in_end in distance_list:
+                if not in_start:
+                    p = point(self.center, d, startangle)
+                    start_nodes.append((d, p, False))
+            start_nodes.sort()
+            assert(len(start_nodes) == len(distance_list))
+            if not self.repair_border_line(start_nodes):
+                logger.debug("end of create_boundary_nodes (failed)")
+                return False
+
+        diff = len(distance_list) - len(end_nodes)
+        if not diff == 0:
+            logger.debug("%s missing end nodes", diff)
+            done = True
+            for d, in_start, in_end in distance_list:
+                if not in_end:
+                    p = point(self.center, d, endangle)
+                    end_nodes.append((d, p, False))
+            end_nodes.sort()
+            assert(len(end_nodes) == len(distance_list))
+
+            if not self.repair_border_line(end_nodes):
+                logger.debug("end of create_boundary_nodes (failed)")
+                return False
+
+        logger.debug("end of create_boundary_nodes")
+        return done
 
     def set_point_of_node(self, node, p):
         if isinstance(node, list):

femagtools/dxfsl/machine.py

@@ -14,6 +14,7 @@ from femagtools.dxfsl.functions import alpha_angle, normalise_angle, middle_angl
 from femagtools.dxfsl.functions import alpha_line, line_m, line_n, mirror_point
 from femagtools.dxfsl.functions import within_interval, part_of_circle
 from femagtools.dxfsl.functions import less, less_equal, greater, greater_equal
+from femagtools.dxfsl.journal import Journal, getJournal
 logger = logging.getLogger('femagtools.geom')
 
 
@@ -38,6 +39,7 @@ class Machine(object):
         self.airgap2_radius = 0.0
         self.airgap_second = None
         self.previous_machine = None
+        self.journal = getJournal()
 
         if not self.center:
             raise ValueError("FATAL ERROR: no center in Geometry")
@@ -554,8 +556,9 @@ class Machine(object):
                               rtol=rtol, atol=atol)
         logger.debug('end of repair_hull_geom')
 
-    def create_boundery_nodes(self):
-        self.geom.create_boundery_nodes(self.center, self.startangle, self.endangle)
+    def create_boundary_nodes(self):
+        if self.geom.create_boundary_nodes(self.center, self.startangle, self.endangle):
+            logger.debug("___additional boundary nodes created___")
 
     def create_auxiliary_lines(self):
         logger.debug("create_auxiliary_lines")

femagtools/ecloss.py

@@ -97,7 +97,7 @@ def binterp(x, y, xq, yq, b):
 
 def binterp_ialh2(x, y, xq, yq, b):
     '''interpolate flux density with Rbf interpolator'''
-    f = RBFInterpolator(np.array([[i, j] for i, j in zip(x, y)]), b)
+    f = RBFInterpolator(np.array([[i, j] for i, j in zip(x, y)]), b, kernel='thin_plate_spline')
     inp = f(np.array([[i, j] for i, j in zip(xq, yq)]))
     return inp.reshape(len(np.unique(xq)), -1)
 
@@ -571,6 +571,10 @@ class MagnLoss(Amela):
         amplb = np.sqrt(amplbx**2 + amplby**2)
         fmax2 = 0.5*freq[-1]
 
+        if sum(amplb) == 0:
+            warnings.warn('Bx and By data equals to zero, check simulation parameters for this loadcase')
+            filt = 0
+
         if sum(amplb) > 0:
             pec = (np.multiply(amplb,freq))**2
             pecmax = np.max(pec)
@@ -604,10 +608,12 @@ class MagnLoss(Amela):
 
         for ii in range (nx):       # Inverse Fourier-Transformation
             for jj in range (ny):
-                sx_pm_3D[ii,jj,0:-1] = np.fft.irfftn(complbx[ii,jj,:])
-                sy_pm_3D[ii,jj,0:-1] = np.fft.irfftn(complby[ii,jj,:])
-        sx_pm_3D[ii,jj,nt-1] = sx_pm_3D[ii,jj,0]
-        sy_pm_3D[ii,jj,nt-1] = sy_pm_3D[ii,jj,0]
+                sx = np.fft.irfftn(complbx[ii,jj,:], [nt - 1])
+                sy = np.fft.irfftn(complby[ii,jj,:], [nt - 1])
+                sx = np.append(sx, sx[0])
+                sy = np.append(sy, sy[0])
+                sx_pm_3D[ii,jj,:] = sx
+                sy_pm_3D[ii,jj,:] = sy
 
         return sx_pm_3D, sy_pm_3D
 
@@ -736,8 +742,7 @@ class MagnLoss(Amela):
 
         nsegx = max(1,nsegx)    #  1 = no segmentation
         nsegz = max(1,nsegz)    #  1 = no segmentation
-        if nsegy != 1:
-            nsegy = 1           # y segmentation not supported, nsegy is always = 1
+        nsegy = 1               # y segmentation not supported, nsegy is always = 1
 
         delta_eff = 0
 
@@ -758,7 +763,7 @@ class MagnLoss(Amela):
                 (sx_abs, sy_abs, sx_phase, sy_phase, freq_range) = self.Process_B_data(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
                 ialh_loss += loss
-                #print(f'Loadcase {i['loadcase']}, Superelement {i['spel_key']}, Total losses =  {loss:.3f} W')
+                logger.info(f'Loadcase {i["loadcase"]}, Superelement {i["spel_key"]}, Total losses =  {loss:.3f} W')
                 loss_detail.append([i['spel_key'], loss/self.numpoles])
             self.th_loss.append(loss_detail)
             all_load_cases.append(ialh_loss)

femagtools/femag.py

@@ -359,42 +359,71 @@ class BaseFemag(object):
 
         return dict()
 
-    def read_hsn(self, modelname=None): 
+    def read_hsn(self, modelname=None):
+        import numpy as np
         "read heat network result"
         _map = {
-            "StZa": "plfe1", 
+            "StZa": "plfe1",
             "outs": "-",
-            "StJo": "plfe1", 
+            "StJo": "plfe1",
             "Slot": "-",
-            "Shaf": "-", 
-            "Iron": "plfe2", 
+            "Shaf": "-",
+            "Iron": "plfe2",
             "PMag": "plmag",
             "PMag_1": "plmag",
             "PMag_2": "plmag",
             "PMag_3": "plmag",
             "PMag_4": "plmag",
-            "W1  ":   "plcu1", 
-            "W2  ":   "plcu1", 
+            "W1  ":   "plcu1",
+            "W2  ":   "plcu1",
             "W3  ":   "plcu1"
         }
         if not modelname:
             modelname = self._get_modelname_from_log()
         hsn_list = sorted(glob.glob(os.path.join(
             self.workdir, modelname+'.hsn')))
-        with open(hsn_list[-1], 'r') as f: 
+        with open(hsn_list[-1], 'r') as f:
             hsn_data = json.load(f)
+
+        # area calculation
+        nc_file = self.read_nc(modelname)
+        slot_area = 0.0
+        wdg_area = []
+        for i in nc_file.windings:
+            for j in i.subregions:
+                wdg_area.append(j.area())
+
+        slot_area = np.sum(wdg_area).item()/3
+        magnet_area = 0.0
+        num_sreg_mag = 0
+        area = dict()
+        for i in nc_file.subregions:
+            if i.name in ("StZa", "StJo", "Iron"):
+                area[i.name] = i.area().item()
+            elif i.name == "PMag":
+                magnet_area += i.area().item()
+                num_sreg_mag += 1
+            else:
+                pass
+
+        area['PMag'] = magnet_area/num_sreg_mag
+        for i in ('W1', 'W2', 'W3'):
+            area[i] = slot_area
+
         pmag_index = []
-        if "Nodes" in hsn_data: 
-            for k ,i in enumerate(hsn_data['Nodes']): 
+        if "Nodes" in hsn_data:
+            for k ,i in enumerate(hsn_data['Nodes']):
                 i.update({"mass": i['weight'], "losses": _map[i['Name']]})
-                if "PMag" in i['Name']: 
+                if "PMag" in i['Name']:
                     pmag_index.append(k)
-            if pmag_index: 
-                for i in range(len(pmag_index)): 
-                    hsn_data["Nodes"][pmag_index[i]]['Name'] = f"PMag_{i+1}" 
-        with open(hsn_list[-1], 'w') as f: 
+                if i['Name'].strip() in area.keys():
+                    i.update({"area": area[i['Name'].strip()]})
+            if pmag_index:
+                for i in range(len(pmag_index)):
+                    hsn_data["Nodes"][pmag_index[i]]['Name'] = f"PMag_{i+1}"
+        with open(hsn_list[-1], 'w') as f:
             json.dump(hsn_data, f)
-        return hsn_data
+        return nc_file
 
     def _get_modelname_from_log(self):
         """
@@ -439,11 +468,13 @@ class BaseFemag(object):
                 return {'t': ttemp[0], 'temperature': ttemp[1]}
 
             if simulation['calculationMode'] == 'hsn':
-                try: 
-                    hsn_result = self.read_hsn()
-                except: 
-                    pass 
-                model = self.read_nc()
+                model = None
+                try:
+                    model = self.read_hsn()
+                except:
+                    pass
+                if model is None:
+                    model = self.read_nc()
                 return model.get_minmax_temp()
 
             if not bch:
@@ -497,7 +528,8 @@ class BaseFemag(object):
                 ops = [k for k in range(len(bch.torque))]
                 m = femagtools.ecloss.MagnLoss(self.workdir, self.modelname, ibeta=ops)
                 try:
-                    magn_losses = m.calc_losses()
+                    # change from ialh to ialh2: since v1.8.1
+                    magn_losses = m.calc_losses_ialh2()
                 except:
                     magn_losses = [0 for i in range(len(ops))]
 
@@ -513,11 +545,11 @@ class BaseFemag(object):
                     bch.magnet_loss_th = m.th_loss
                 except:
                     pass
-            try: 
-                if hasattr(self, 'dy2'): 
+            try:
+                if hasattr(self, 'dy2'):
                     setattr(bch, 'dy2', self.dy2)
-            except: 
-                pass 
+            except:
+                pass
             return bch
 
 
@@ -649,10 +681,10 @@ class Femag(BaseFemag):
             stateofproblem = 'mag_static'
 
         self.run(fslfile, options, fsl_args, stateofproblem=stateofproblem)
-        
-        try: 
+
+        try:
             setattr(self, "dy2", machine['stator']['dy2'])
-        except: 
+        except:
             pass
         if simulation:
             return self.readResult(simulation)

femagtools/fsl.py

@@ -157,10 +157,18 @@ class Builder:
                     + model.stator['dxf']['fsl'])
         if templ == 'statorFsl':
             #  obsolete
+            th_props = [' ']
+            try: 
+                th_props = [f'stator_density = {model.stator["density"]}',
+                            f'stator_thcond = {model.stator["thcond"]}',
+                            f'stator_thcap = {model.stator["thcap"]}',
+                            ]
+            except: 
+                pass 
             if 'parameter' in model.stator['statorFsl']:
                 return self.render_template(
                     model.stator['statorFsl']['content_template'],
-                    model.stator['statorFsl']['parameter'])
+                    model.stator['statorFsl']['parameter']) + th_props
             elif model.stator['statorFsl'].get('content'):
                 return (['agndst = {}'.format(model.get('agndst', 1e-3)*1e3),
                         'ndt(agndst)'] +
@@ -214,16 +222,24 @@ class Builder:
                .format(model.magnet.get('mcvkey_yoke', 'dummy')),
                "mcvkey_shaft = '{}'"
                .format(model.magnet.get('mcvkey_shaft', 'dummy'))]
-
         if 'magnetFsl' in model.magnet:
             self.fsl_rotor = True
             #  obsolete
+            th_props = [' ']
+            try: 
+                logger.info(model.magnet)
+                th_props = [f'rotor_density = {model["magnet"]["density"]}',
+                            f'rotor_thcond = {model["magnet"]["thcond"]}',
+                            f'rotor_thcap = {model["magnet"]["thcap"]}'
+                            ]
+            except: 
+                pass 
             if 'parameter' in model.magnet['magnetFsl']:
                 return mcv + self.render_template(
                     model.magnet['magnetFsl']['content_template'],
-                    model.magnet['magnetFsl']['parameter'])
+                    model.magnet['magnetFsl']['parameter']) + th_props
             elif model.magnet['magnetFsl'].get('content'):
-                return mcv + model.magnet['magnetFsl']['content'].split('\n')
+                return mcv + model.magnet['magnetFsl']['content'].split('\n') 
             if isinstance(model.magnet['magnetFsl']
                           ['content_template'], str):
                 with open(model.magnet['magnetFsl']
@@ -231,9 +247,8 @@ class Builder:
                     templ = [l.strip() for l in f.readlines()]
             else:
                 templ = model.magnet['magnetFsl']['content_template']
-
             return mcv + self.render_template(
-                '\n'.join(templ),
+                '\n'.join(templ), 
                 model.magnet['magnetFsl'])
 
         templ = model.magnettype()

femagtools/machine/sm.py

@@ -344,13 +344,13 @@ class SynchronousMachine(object):
             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): 
+            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: 
+            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]
@@ -806,10 +806,7 @@ class SynchronousMachinePsidq(SynchronousMachine):
             if 'styoke_excess' in eecpars[idname][0]['losses'] and \
                np.any(np.array(eecpars[idname][0]['losses']['styoke_excess'])):
                 self.bertotti = True
-                keys.update({{
-                    'styoke_excess': 1.5,
-                    'stteeth_excess':1.5,
-                    'rotor_excess': 1.5}})
+                keys += ['styoke_excess', 'stteeth_excess','rotor_excess']
             if islinear:
                 pfe = {k: np.array([l['losses'][k]
                                     for l in eecpars[idname]])
@@ -926,10 +923,7 @@ class SynchronousMachineLdq(SynchronousMachine):
             if 'styoke_excess' in eecpars[idname][0]['losses'] and \
                np.any(np.array(eecpars[idname][0]['losses']['styoke_excess'])):
                 self.bertotti = True
-                keys.update({{
-                    'styoke_excess': 1.5,
-                    'stteeth_excess':1.5,
-                    'rotor_excess': 1.5}})
+                keys += ['styoke_excess', 'stteeth_excess','rotor_excess']
 
             if islinear:
                 pfe = {k: np.array([l['losses'][k]

femagtools/templates/afm_rotor.mako

@@ -91,7 +91,11 @@ m.nodedist        = ${model.get('nodedist', 1)}
   x,y = (P22.x+P32.x)/2,(P21.y+P22.y)/2
   if m.remanenc == nil then
     m.remanenc = 1.2
+  end
+  if m.relperm == nil then
     m.relperm = 1.05
+  end
+  if m.rlen == nil then
     m.rlen = 100
   end
   for i = 1,m.npols_gen do

femagtools/templates/prepare_thermal.mako

@@ -40,12 +40,12 @@ shaft_spel = {} ---- lightgrey, 16
 magnet_spel = {} -- black, 8
 outer_air = {} -- darkred, 10
 inner_air = {} -- lightgrey, 16
-rotor_air = {} 
+rotor_air = {}
 stator_air = {} -- black, 8
 airgap = {} -- white, 8
 magnet_pocket_spel = {}  -- red, 1
 non_uniform_airgap = {} -- white, 8
-slot_opening = {} 
+slot_opening = {}
 slot_sreg_exist = 0
 -- search all components
 for i =1,  #spel_keys do
@@ -74,7 +74,7 @@ for i =1,  #spel_keys do
 %if model.get('htc_outer', 0):
               def_heat_transfer(xc,yc,yellow,${model['htc_outer']}, 1.0)
 %endif
-              color_spel(spel_keys[i], 10) 
+              color_spel(spel_keys[i], 10)
 
            elseif rc > dy2/2 and rc < da2/2 then
               -- rotor air
@@ -87,14 +87,14 @@ for i =1,  #spel_keys do
               -- stator air
               table.insert(stator_air, spel_keys[i])
               def_mat_therm(xc, yc, 'yellow', 1.19,0.15,1007, 1)
-              color_spel(spel_keys[i], 8) 
+              color_spel(spel_keys[i], 8)
               key_exist_sl = get_sreg_key(xc, yc)
-              if key_exist_sl <= 0 and slot_sreg_exist == 0 then 
+              if key_exist_sl <= 0 and slot_sreg_exist == 0 then
                   def_new_sreg(xc, yc, 'Slot', 'yellow')
                   slot_sreg_exist = 1
-              else 
+              else
                   add_to_sreg(xc, yc, 'Slot')
-              end        
+              end
            elseif rc > da2/2 and rc < da1/2 then
               table.insert(airgap, spel_keys[i])
               def_mat_therm(xc, yc, 'yellow', 1.19,0.15,1007, 1)
@@ -139,83 +139,83 @@ end
 
 function is_exist(arr, val)
    local i
-   if #arr == 0 then 
-      return false 
-   end 
-   for i = 1, #arr do 
-      if arr[i] == val then 
+   if #arr == 0 then
+      return false
+   end
+   for i = 1, #arr do
+      if arr[i] == val then
          return true
-      end 
-   end 
+      end
+   end
    return false
-end 
--- identify magnet air pocket 
+end
+-- identify magnet air pocket
 
-for i = 1, #magnet_spel do 
+for i = 1, #magnet_spel do
     bkeys = get_spel_data ( "bndkeys", magnet_spel[i])
-    for j = 1, #bkeys do 
+    for j = 1, #bkeys do
          elks = get_node_data ( "elkeys", bkeys[j] )
-         for k = 1, #elks do 
+         for k = 1, #elks do
             p1, p2 = get_elem_data("perm", elks[k])
             sek = get_elem_data("sekey", elks[k])
-            if p1 == 1.0 then 
-                  if (not is_exist(magnet_pocket_spel, sek)) and (not is_exist(airgap, sek)) then  
+            if p1 == 1.0 then
+                  if (not is_exist(magnet_pocket_spel, sek)) and (not is_exist(airgap, sek)) then
                      table.insert(magnet_pocket_spel, sek)
                      els = get_spel_data('elkeys', sek)
                      xc, yc = get_xy(els[1])
                      def_mat_therm(xc, yc, 'red', 1.12,0.026,1007, 1)
                      --table.remove(rotor_air, sek)
                      color_spel(sek, 1)
-                  end 
-            end 
-         end 
-    end 
-end 
+                  end
+            end
+         end
+    end
+end
 
 
 
-for i = 1, #rotor_air do 
-  if rotor_air[i] ~= nil then 
+for i = 1, #rotor_air do
+  if rotor_air[i] ~= nil then
     bkeys = get_spel_data ( "bndkeys", rotor_air[i])
-    for j = 1, #bkeys do 
+    for j = 1, #bkeys do
       x, y = get_node_data ( "xy", bkeys[j] )
-      r, phi = c2pd(x, y) 
-      if math.abs(r - da2/2) < 1e-5 then 
-        if not is_exist(non_uniform_airgap,rotor_air[i]) then 
+      r, phi = c2pd(x, y)
+      if math.abs(r - da2/2) < 1e-5 then
+        if not is_exist(non_uniform_airgap,rotor_air[i]) then
           table.insert(non_uniform_airgap, rotor_air[i])
           els = get_spel_data('elkeys', rotor_air[i])
           xc, yc = get_xy(els[1])
           def_mat_therm(xc, yc, 'yellow', 1.19,1.15,1007, 1)
           add_to_sreg(xc, yc, 'Slot')
           color_spel(rotor_air[i], 7)
-        end 
-      end 
-    end 
-  end 
-end 
+        end
+      end
+    end
+  end
+end
 
-for i = 1, #rotor_air do 
-  if rotor_air[i] ~= nil then 
-    if is_exist(non_uniform_airgap, rotor_air[i]) then 
+for i = 1, #rotor_air do
+  if rotor_air[i] ~= nil then
+    if is_exist(non_uniform_airgap, rotor_air[i]) then
       rotor_air[i] = nil
-    end    
-  end 
-end 
+    end
+  end
+end
 
-for i = 1, #rotor_air do 
-   if is_exist(magnet_pocket_spel, rotor_air[i]) then 
+for i = 1, #rotor_air do
+   if is_exist(magnet_pocket_spel, rotor_air[i]) then
      rotor_air[i] = nil
-   end 
- end 
- 
+   end
+ end
 
-for i = 1, #rotor_air do 
-   if rotor_air[i] ~= nil then 
+
+for i = 1, #rotor_air do
+   if rotor_air[i] ~= nil then
       els = get_spel_data('elkeys', rotor_air[i])
       xc, yc = get_xy(els[1])
       def_mat_therm(xc, yc, 'red', 1.12,0.026,1007, 1)
-   end 
-end 
+   end
+end
 
 
 save_metafile(model..'.ps')
@@ -322,7 +322,10 @@ end
 
 
 rn, phin = get_boundary_node(m.tot_num_slot)
-thickness = ${model.get('slot_insul', 0.15)}
+thickness = ${model.windings.get('slot_insulation_thickness', 0.15e-3)*1e3}
+if thickness == 0.0 then 
+   thickness = 0.15
+end 
 conductivity = ${model.get('slot_insul_cond', 0.31)}
 
 for i = 1,m.num_sl_gen do
@@ -331,7 +334,7 @@ y = {}
 
 for j = 1, #rn do
    x[j], y[j] = pd2c(rn[j], phin[j] + (i-1)*360/m.tot_num_slot)
-   point(x[j], y[j],"black","x") 
+   point(x[j], y[j],"black","x")
 end
 
 def_insulation_by_nodechain(thickness,conductivity,

{femagtools-1.8.0.dist-info → femagtools-1.8.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: femagtools
-Version: 1.8.0
+Version: 1.8.1
 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

{femagtools-1.8.0.dist-info → femagtools-1.8.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-femagtools/__init__.py,sha256=LOLIDnRqx1rFlY3VW2IB1PaBPwEYtzPgv2UIqP0QKZU,1600
+femagtools/__init__.py,sha256=8qBE3W14xsW2ubtd47GQKlMz2Q3iiSOKk2UAcacUMJI,1600
 femagtools/airgap.py,sha256=hELJXe52yUw82JwZ1tGUXUtRhMG2_WSUBVeGkTZSAM8,1900
 femagtools/amazon.py,sha256=O1ICuv21XDAJi1qK1Sigs2TdS6hDZP19OzvmE2t76wU,12069
 femagtools/amela.py,sha256=RFTuQ5EcX19G2YJchnktr6j62mNptrdTreShQDOeuKA,13874
@@ -13,11 +13,11 @@ femagtools/dakota.py,sha256=L2zZdACdhso7szwN_s5tsmeEbcuUygE2JK4SxwtL79w,6901
 femagtools/dakota_femag.py,sha256=ipmMUMTK1mvMpfHJJjwHa_4kx7BItYO3ha8MeYJTyy8,4068
 femagtools/dakotaout.py,sha256=6nn0PXsB40mPKiQLenqAtHy0KXCO7kvqqQ-aD2JhQvw,5573
 femagtools/docker.py,sha256=XDVmLBB0z4sZZpcrx7Wbm84xl4ksj7aqn5-ZOPxdxm4,7460
-femagtools/ecloss.py,sha256=0nD2_R7ISl6OGG_l8FLi27ynLG9SlzhJBy13sBoR8Ts,33743
+femagtools/ecloss.py,sha256=kTsE9Lx6nt6Ez9PBfD58hPMcnH2PxSc95zJaYMCQd5Q,33957
 femagtools/erg.py,sha256=IXKq76P9qLt_ssNOP78v8Qizk3J2Zg80yaKDSjzwoJE,1224
-femagtools/femag.py,sha256=5zOcfUHkAgdhWsOROuAijLaTQMt7JF5xpszwQR_G7Zs,45990
+femagtools/femag.py,sha256=m8mfMjzjkL_R-iqyInxM7y7F4jgKg6ZI7FfTQlbxtng,46988
 femagtools/forcedens.py,sha256=7NNv75Vg9vQ_fy8W4kM2rlSO970zaSmeurhPmdAxsOU,8485
-femagtools/fsl.py,sha256=Ap-U7g3BO8uBGUyElkwRgaHHK0WK5XDRC7NfdXaK8lk,36182
+femagtools/fsl.py,sha256=XktbwR4KvUVv-Fq_9FMPbigBvrHYfSdL6P0kcwAx5Mg,36929
 femagtools/getset.py,sha256=yJ6Em35DeWK7WNZW0qjjS5s7LUkVh5mbgxF59HHm5FM,3017
 femagtools/gmsh.py,sha256=IKhNiviIBji4cMxAhxaYXNqBRMNAPSKsBGdnGyxkyQw,3903
 femagtools/google.py,sha256=ugRyHY1zBjHR4aNfbA7GeF-ZU_NgleuVTZaWpi_XLT4,17144
@@ -48,20 +48,20 @@ femagtools/vbf.py,sha256=9XGfhftmD9carU8ByQ5DwqoR4daq5mJ39eMqruwml0Q,2444
 femagtools/vtu.py,sha256=Sf83dHIfCKY2km-MIUHKKoj-JKN4PDX7kkPLZXyIYY4,10723
 femagtools/windings.py,sha256=OYoEFIQci3f3sYJkcyRjBpBpDRtX2Y2aHZiRXOEgsls,23497
 femagtools/dxfsl/__init__.py,sha256=MywcCdpKPKs4qJBJJgeDsikJFJ2P48dbTuNk303f5pM,76
-femagtools/dxfsl/area.py,sha256=74VwDSvBLrxpIo_oxU3FGbg3ef_4L8F2IJTG-dJArz8,65208
+femagtools/dxfsl/area.py,sha256=d991y_mLGapilCQyp3ZK6mXbUeXEt-nAkJWJ5P0yxXo,65227
 femagtools/dxfsl/areabuilder.py,sha256=Siu11yRcNJiSCWwc865-OvuVhSmLtRQWysbe1-rUcN0,34197
 femagtools/dxfsl/concat.py,sha256=F6scwesxyOmfmKQ5kGspNCxA71Yz6QgxFL7lTj3hsaI,13385
-femagtools/dxfsl/conv.py,sha256=TaYqaeRwrK98mPh9uH33SmpmVW48U2v-qnDKs2cjcj8,10600
-femagtools/dxfsl/converter.py,sha256=B0r9MWZbsiIWukHotZ7NMq8rse1FadAaOblxbvDDyw4,34490
+femagtools/dxfsl/conv.py,sha256=-d03mQiDWF_MD4T0TIH7k-zNa6p7w9rtc6QE2Bz1Q7s,10362
+femagtools/dxfsl/converter.py,sha256=8Bm3JQaK6IwZBil6n5avaydd7Nkvj8tRNGbqWU4EHU8,35525
 femagtools/dxfsl/corner.py,sha256=-XPBcnEau-2-SRHLYzlBqCQGaFfgm_DH2qR1mSaFoAs,1311
 femagtools/dxfsl/dumprenderer.py,sha256=n4AvInjvGIaC2iKZtQaYXXDyJVSQ3uEOFOLD4-xfKRY,1861
 femagtools/dxfsl/dxfparser.py,sha256=kyXG0kZfNyOgn96MqBgP8RhOQhppfB5NbyRNNybs1C0,13451
 femagtools/dxfsl/femparser.py,sha256=O8940Q1Mz8MKng6W8M3s9KfTvhDLJ56tfQWtZEW3xMM,2134
-femagtools/dxfsl/fslrenderer.py,sha256=Z6jLpwuDCwUyQFf9YinSnJ7u_9WAb71MIgSOugdt0-8,27540
+femagtools/dxfsl/fslrenderer.py,sha256=v2z6GJPuuI0FDxHENw_Oteejz5GZzgc5nr0fjffH3q8,27904
 femagtools/dxfsl/functions.py,sha256=teJHtVxoViGs66AB8_4BxRrFQx9SbPT2azIrKyhJHOc,12005
-femagtools/dxfsl/geom.py,sha256=iHrHdC8yOTfE1bRSbsM2hVd0LH_sx7Ws42-SX0TBSzM,172502
+femagtools/dxfsl/geom.py,sha256=Q0pxdT3qtUs7lg3RmJ-_7RhlnM9n9_xE_LRjJeNpf4E,174555
 femagtools/dxfsl/journal.py,sha256=4LMSW5wCYlETzid6SIF8b5DH-DCgtH4nFx-xIxjtbfg,4265
-femagtools/dxfsl/machine.py,sha256=M6KzOzmeb3Al2Hp3BjlgYWKGpbRrOPwKeN5VFXS2qF8,50415
+femagtools/dxfsl/machine.py,sha256=vaELJixMKrjJTOe5QNb5aXVG17vN0KbMQaI1arNzYd0,50580
 femagtools/dxfsl/plotrenderer.py,sha256=q2cORuxJEf1Ws6oCY9c0gF6N3kDrcI6WOz3u5Vl6R_c,13823
 femagtools/dxfsl/shape.py,sha256=kz68mPsK1m5jRnE-5iNS3FX2IkpSHOe0X3OdEklGR80,59970
 femagtools/dxfsl/svgparser.py,sha256=FE8Jk3pV6e4AtJlrJuUxz89_JZC9buS0wwTBsX52O1g,3762
@@ -72,7 +72,7 @@ femagtools/machine/effloss.py,sha256=GV_bc5f1ysBi1Ng7FR3fD1xh5KXa6ACc55iWfsltMBI
 femagtools/machine/im.py,sha256=3Y54AHMZfAjkvgexx2E-5jxNWzaVQ-SyaETCh7gNBYA,38008
 femagtools/machine/pm.py,sha256=C4vDdPIsIRUKtzY3b1RNT1v37p1uP3pMUduftNejcPc,68129
 femagtools/machine/sizing.py,sha256=nWCfxbyWfbw5-7xu0qZ6zjWNquEPn3fUH-fQeGb6QUc,24307
-femagtools/machine/sm.py,sha256=y_zPZN0gGKUQL8RCyhyyfeJE_cSRPK5Mmk93HQPzTFM,39379
+femagtools/machine/sm.py,sha256=Y6g4KPm-2bhzMYjGarojokEzaNgOmFR2G4DIKBtVQOs,39210
 femagtools/machine/utils.py,sha256=CRTY5qwlaN_Zp5SZgxicXTfZyVU5fjtm4XKEA-peNCc,20856
 femagtools/moo/__init__.py,sha256=zinmWEOrsEz6DmMX0Dbn4t6_1UR-p4bEGqyR1wUQk_Q,175
 femagtools/moo/algorithm.py,sha256=e-Cgp2rp_hG9DXqWqluzQGNIWvCfthUgLD8O-aVPofA,5763
@@ -93,7 +93,7 @@ femagtools/plot/phasor.py,sha256=5QG1GkXKVksc8P6Q4thKADf6W1l8rDKeArIHFYvbXlw,485
 femagtools/plot/wdg.py,sha256=Orw2XGThHpOuJ_raSRnQTzj5tOmwllNWweByoOXbA7I,9820
 femagtools/svgfsl/converter.py,sha256=5q4LognshXNTpUWLnU5rtgCfAwZnEuPzqsgyeRYC-VM,3019
 femagtools/templates/FE-losses.mako,sha256=Rql5_8Q6_uthpr-uFXMUo7tdHehfZYND-7M-ohJXVU8,874
-femagtools/templates/afm_rotor.mako,sha256=fY-dlZvRLN9UAy5V6Q_inWghkSUe8pzrCYjJdNgfNXs,3112
+femagtools/templates/afm_rotor.mako,sha256=4yoEA4fOq9FRcwxOMRw1oX4Bs_jcrtyHOY6kHPYJ5MY,3175
 femagtools/templates/afm_stator.mako,sha256=l1xEwxffZ1jyx5wuJ3rhVbVlZirJzD2K8n4i5Dvbxuc,5344
 femagtools/templates/airgapinduc.mako,sha256=aCMLZ7P4vjeSGikIetkwymgDjESdftPN_aYx2LfjfsY,246
 femagtools/templates/asyn_motor.mako,sha256=vvZ0SIJj4ORaCbE1Hl5NeCU_j2CWdOltVpSKP7ESJTQ,2879
@@ -143,7 +143,7 @@ femagtools/templates/plots.mako,sha256=6xfmncVbzDiJLF6V0B6fha23H19R7P26DvcTTwzJ5
 femagtools/templates/pm_sym_f_cur.mako,sha256=KlskcNx5Y_HNwt2crA7CqHN5TIaKBb14T6cFg2vghl0,1464
 femagtools/templates/pm_sym_fast.mako,sha256=NOSbuWSEM2XGY5-JweGxSr32mXGBVSas_aSOQyK4uEU,2361
 femagtools/templates/pm_sym_loss.mako,sha256=dh0o3ZamZuWs7sHc-jS7ohKsqeZCA0tRaqkaFmXlRS0,1009
-femagtools/templates/prepare_thermal.mako,sha256=H8YRqE8i5AiRPl-dE3obiMhiuO9vm5L7ASeqPJoUozg,9521
+femagtools/templates/prepare_thermal.mako,sha256=V3W6BGW7gjY8Lg2qzvGDi8rxx3JvPzrWoABDvHKyq54,9539
 femagtools/templates/psd_psq_fast.mako,sha256=7DQUZI6KOjdKQMFLKySGUlWXo4U_rZuHXFzLxiA1GGc,1339
 femagtools/templates/ring.mako,sha256=Cuc_FuCPWZM-g3TxHqzTdjknYEJSUgP-y64gp8pekDI,643
 femagtools/templates/rot_hsm.mako,sha256=eh50TbpWNUALK9_7wOOJ7KPewHos7JExAfMACbPlXYc,973
@@ -213,9 +213,9 @@ tests/moo/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/moo/test_algorithm.py,sha256=Em8sFm2vzPmuIzRrBBnUQLU_TYuJHSf-kEeozw0XeX4,2563
 tests/moo/test_population.py,sha256=FvX9LRCxQx0_E2GxHQ5vKwOYFBQiNbT6Lmv5GmNWjTQ,5471
 tests/moo/test_problem.py,sha256=ALeP4u7g-dFhfwWL8vxivdrrYzVKPjHMCAXzzgyNZbs,467
-femagtools-1.8.0.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
-femagtools-1.8.0.dist-info/METADATA,sha256=qZkw13rq-jo1WT373nahzfRdxT1VvBAnMgKBhiDK_5A,6198
-femagtools-1.8.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-femagtools-1.8.0.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
-femagtools-1.8.0.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
-femagtools-1.8.0.dist-info/RECORD,,
+femagtools-1.8.1.dist-info/LICENSE,sha256=NaQe4uvkszQPJmiRPHecfk-Ab9VSRXo8xQLGNVHTeFo,1362
+femagtools-1.8.1.dist-info/METADATA,sha256=vMKM0Pd8bfajkKv7bXpXco4_dmISFQXGJKQRtQDb9xE,6198
+femagtools-1.8.1.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+femagtools-1.8.1.dist-info/entry_points.txt,sha256=jrvOkZPiN44u1sASeu271VRaVIv5V-uRpN0_N5U_R8c,248
+femagtools-1.8.1.dist-info/top_level.txt,sha256=Ri4YWtU8MZTzNje9IKyXhTakNbsrCynuWdon4Yq94Dc,17
+femagtools-1.8.1.dist-info/RECORD,,