femagtools 1.8.0__tar.gz → 1.8.1__tar.gz

{femagtools-1.8.0/src/femagtools.egg-info → femagtools-1.8.1}/PKG-INFO

@@ -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 → femagtools-1.8.1}/src/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-1.8.0 → femagtools-1.8.1}/src/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-1.8.0 → femagtools-1.8.1}/src/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-1.8.0 → femagtools-1.8.1}/src/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-1.8.0 → femagtools-1.8.1}/src/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-1.8.0 → femagtools-1.8.1}/src/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-1.8.0 → femagtools-1.8.1}/src/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-1.8.0 → femagtools-1.8.1}/src/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)