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

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")
@@ -245,16 +247,21 @@ class Machine(object):
                            startangle=self.startangle,
                            endangle=self.endangle)
 
-    def full_copy(self, concatenate_matching_el=False):
+    def clone(self):
         clone = self.geom.copy_shape(self.radius,
                                      0.0, 2*np.pi,
-                                     0.0, self.radius+9999,
-                                     concatenate_matching_el=concatenate_matching_el)
+                                     0.0,
+                                     self.radius+9999,
+                                     concatenate=False,
+                                     connect=False)
         clone.kind = self.geom.kind
         clone.sym_part = self.geom.sym_part
         clone.sym_counterpart = self.geom.sym_counterpart
         clone.alfa = self.geom.alfa
-        self.geom = clone
+        return Machine(clone,
+                       radius = self.radius,
+                       startangle=self.startangle,
+                       endangle=self.endangle)
 
     def copy_mirror(self, startangle, midangle, endangle):
         logger.debug("begin of copy_mirror")
@@ -530,7 +537,7 @@ class Machine(object):
         logger.debug('begin repair_hull_geom (%s, %s)', startangle, endangle)
 
         rtol = 1e-3
-        atol = 1e-4
+        atol = 1e-3
         c_corner = Corner(self.center, self.center)
         start_c_added, start_corners = geom.get_corner_list(self.center, startangle,
                                                             rtol=rtol, atol=atol)
@@ -554,8 +561,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")
@@ -587,8 +595,34 @@ class Machine(object):
         return w
 
     def slot_area(self):
-        from .area import TYPE_WINDINGS
-        return self.geom.area_size_of_type(TYPE_WINDINGS)
+        return self.geom.area_size_of_type(AREA.TYPE_WINDINGS)
+
+    def get_winding_symmetry(self, inside=False):
+        logger.debug("begin of get_winding_symmetry")
+        symmetry = Symmetry(geom=self.geom,
+                            startangle=self.startangle,
+                            endangle=self.endangle)
+        parts = symmetry.get_winding_symmetry(inside=inside)
+        logger.debug("end of get_winding_symmetry (parts=%s)", parts)
+        return parts
+
+    def get_magnet_symmetry(self):
+        logger.debug("begin of get_magnet_symmetry")
+        symmetry = Symmetry(geom=self.geom,
+                            startangle=self.startangle,
+                            endangle=self.endangle)
+        parts = symmetry.get_magnet_symmetry()
+        logger.debug("end of get_magnet_symmetry (parts=%s)", parts)
+        return parts
+
+    def get_symmetry(self):
+        logger.debug("begin of get_symmetry")
+        symmetry = Symmetry(geom=self.geom,
+                            startangle=self.startangle,
+                            endangle=self.endangle)
+        parts = symmetry.find_symmetry()
+        logger.debug("end of get_symmetry (parts=%s)", parts)
+        return parts
 
     def find_symmetry(self, sym_tolerance, is_inner, is_outer, plt):
         logger.debug("begin of find_symmetry")
@@ -758,6 +792,97 @@ class Machine(object):
                              self.geom.symmetry_endangle()))
         return machine_slice
 
+    def get_forced_winding_slice(self):
+        logger.debug("get_forced_winding_slice()")
+        if not self.geom.is_outer:
+            return None
+
+        areas = len(self.geom.area_list)
+        winding_areas = self.geom.num_of_windings()
+        iron_areas = self.geom.num_of_irons()
+        air_areas = self.geom.num_areas_of_type((AREA.TYPE_AIR,))
+
+        if not (winding_areas + iron_areas + air_areas == areas):
+            logger.warning("Warning: strange areas in stator")
+
+        if winding_areas == 0:
+            return self.get_possible_windings()
+
+        if winding_areas < 2:
+            return None  # nothing to do
+        parts = self.get_winding_symmetry()
+        if parts < 2:
+            return None  # nothing to do
+        return self.get_symmetry_slice()
+
+    def get_possible_windings(self, EESM=False, single=False):
+        if not self.geom.is_outer:
+            return None
+
+        machine = self.clone()
+        machine.repair_hull()
+        machine.set_alfa_and_corners()
+        machine.geom.set_subregion_parameters(self.startangle,
+                                              self.endangle)
+        machine.geom.looking_for_corners()
+        dist_start = machine.geom.dist_start_min_corner()
+        dist_end = machine.geom.dist_end_min_corner()
+
+        if not np.isclose(dist_start, dist_end, rtol=1e-3, atol=1e-3):
+            angle = machine.geom.alfa
+            if dist_start > dist_end:
+                machine.mirror_all_areas(self.startangle)
+                machine.rotate_to(angle)
+                machine.geom.create_list_of_areas(delete=True)
+                machine.startangle -= angle
+            else:
+                machine.mirror_all_areas(self.endangle)
+                machine.endangle += angle
+            machine.set_alfa_and_corners()
+            machine.part = machine.part_of_circle()
+            machine.geom.set_subregion_parameters(self.startangle,
+                                                  self.endangle)
+            machine.geom.looking_for_corners()
+
+        if machine.geom.close_outer_winding_areas():
+            machine.geom.create_list_of_areas(delete=True)
+            machine.geom.set_subregion_parameters(self.startangle,
+                                                  self.endangle)
+            machine.geom.looking_for_corners()
+            parts = machine.get_winding_symmetry(inside=True)
+
+            if parts == 1:
+                return machine
+            if parts > 1:
+                return machine.get_symmetry_slice()
+
+        return machine
+
+    def get_forced_magnet_slice(self):
+        logger.debug("get_forced_magnet_slice()")
+        areas = len(self.geom.area_list)
+        magnet_areas = self.geom.num_of_magnets()
+        iron_areas = self.geom.num_of_irons()
+        air_areas = self.geom.num_areas_of_type((AREA.TYPE_AIR,))
+
+        if magnet_areas < 2:
+            return None  # nothing to do
+        parts = self.get_magnet_symmetry()
+
+        if parts < 2:
+            return None  # nothing to do
+        slice = self.get_symmetry_slice()
+        match = slice.geom.min_max_corners_match()
+        while parts > 1 and not match:
+            parts = parts - 1
+            self.geom.rotate_symmetry_parameters()
+            slice = self.get_symmetry_slice()
+            match = slice.geom.min_max_corners_match()
+        if match:
+            slice.geom.set_rotor()
+            return slice
+        return None
+
     def get_forced_symmetry(self, part):
         logger.debug("begin get_forced_symmetry")
         if not self.is_full():
@@ -1038,6 +1163,13 @@ class Machine(object):
 
     def sync_with_counterpart(self, cp_machine):
         logger.debug("sync_with_counterpart")
+
+        def not_tiny_areas(geom):
+            sz_list = [a.area_size() for a in geom.list_of_areas()]
+            max_sz = max(sz_list)
+            large_sz_list = [sz for sz in sz_list if sz > max_sz * 0.005]
+            return len(large_sz_list)
+
         self.geom.sym_counterpart = cp_machine.get_symmetry_part()
         self.geom.sym_part = self.get_symmetry_part()
         logger.debug("part/sym-part: self=%s/%s, cp=%s/%s",
@@ -1046,6 +1178,14 @@ class Machine(object):
         cp_machine.geom.sym_counterpart = self.get_symmetry_part()
         cp_machine.geom.sym_part = cp_machine.get_symmetry_part()
 
+        if not_tiny_areas(self.geom) == 1:
+            if not_tiny_areas(cp_machine.geom) > 1:
+                self.geom.force_to_be_stator()
+                cp_machine.geom.force_to_be_rotor()
+        elif not_tiny_areas(cp_machine.geom) == 1:
+            self.geom.force_to_be_rotor()
+            cp_machine.geom.force_to_be_stator()
+
     def search_subregions(self, EESM, single=False):
         logger.debug("Search subregions")
         self.geom.search_subregions(self.startangle,
@@ -1070,8 +1210,7 @@ class Machine(object):
 
     def rebuild_subregions(self, EESM, single=False):
         logger.debug("Rebuild subregions")
-        self.geom.set_edge_attributes()
-        self.geom.area_list = []
+        self.geom.create_list_of_areas(delete=True)
         self.geom.search_subregions(self.startangle,
                                     self.endangle,
                                     EESM,
@@ -1139,6 +1278,11 @@ class Machine(object):
                                 self.endangle)
         return self.geom.windings_in_the_middle(midangle)
 
+    def has_magnets_in_the_middle(self):
+        midangle = middle_angle(self.startangle,
+                                self.endangle)
+        return self.geom.magnets_in_the_middle(midangle)
+
     def create_mirror_lines_outside_windings(self):
         logger.debug("create_mirror_lines_outside_windings")
 
@@ -1269,3 +1413,14 @@ class Machine(object):
             self.clear_cut_lines()
             self.repair_hull()
             self.set_alfa_and_corners()
+
+    def mirror_all_areas(self, mirror_angle):
+        self.geom.mirror_all_areas(mirror_angle)
+
+    def check_airgap_connecting_nodes(self, m_outer):
+        logger.info("check_airgap_connecting_nodes")
+        assert(self.geom.is_inner)
+        assert(m_outer.geom.is_outer)
+        self.geom.check_airgap_connecting_nodes(m_outer.geom,
+                                                self.startangle,
+                                                self.endangle)

femagtools/dxfsl/shape.py

@@ -11,7 +11,7 @@ from __future__ import print_function
 import numpy as np
 import logging
 from .functions import less_equal, greater_equal
-from .functions import distance, line_m, line_n
+from .functions import distance, line_m, line_n, mirror_point
 from .functions import point, points_are_close, points_on_arc
 from .functions import alpha_line, alpha_angle, alpha_triangle
 from .functions import normalise_angle, min_angle, max_angle, get_angle_of_arc
@@ -54,6 +54,9 @@ class Shape(object):
     def classname(self):
         return "Shape"
 
+    def clone(self):
+        return None
+
     def set_my_color(self, color):
         self.my_color = color
 
@@ -314,6 +317,32 @@ class Shape(object):
     def is_near(self, n):
         return False
 
+    def mirror_shape(self, geom_center, axis_m, axis_n):
+        n2 = mirror_point(self.start(), geom_center, axis_m, axis_n)
+        n1 = mirror_point(self.end(), geom_center, axis_m, axis_n)
+
+        el = None
+        if isinstance(self, Line):
+            el = Line(Element(start=n1, end=n2))
+
+        elif isinstance(self, Arc):
+            c = mirror_point(self.center, geom_center, axis_m, axis_n)
+            alpha1 = alpha_line(c, n1)
+            alpha2 = alpha_line(c, n2)
+            el = Arc(Element(center=c,
+                             radius=self.radius,
+                             start_angle=alpha1*180/np.pi,
+                             end_angle=alpha2*180/np.pi))
+
+        elif isinstance(self, Circle):
+            c = mirror_point(self.center, geom_center, axis_m, axis_n)
+            el = Circle(Element(center=c,
+                                radius=self.radius))
+
+        if el:
+            el.copy_attributes(self)
+        return el
+
     def print_nodes(self):
         return " n1={}/n2={}".format(self.n1, self.n2)
 
@@ -354,6 +383,10 @@ class Circle(Shape):
     def classname(self):
         return "Circle"
 
+    def clone(self):
+        return Circle(Element(center=self.center,
+                              radius=self.radius))
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -742,6 +775,14 @@ class Arc(Circle):
     def classname(self):
         return "Arc"
 
+    def clone(self):
+        alpha_start = alpha_line(self.center, self.p1)
+        alpha_end = alpha_line(self.center, self.p2)
+        return Arc(Element(center=self.center,
+                           radius=self.radius,
+                           start_angle=alpha_start*180/np.pi,
+                           end_angle=alpha_end*180/np.pi))
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:
@@ -1285,6 +1326,10 @@ class Line(Shape):
     def classname(self):
         return "Line"
 
+    def clone(self):
+        return Line(Element(start=self.p1,
+                            end=self.p2))
+
     def render(self, renderer, color='blue', with_nodes=False):
         tmp_color = self.get_my_color()
         if not tmp_color:

femagtools/dxfsl/svgparser.py

@@ -106,7 +106,7 @@ def svgshapes(svgfile):
     for p in svg.findall(".//{http://www.w3.org/2000/svg}path"):
         m = bcolor.search(p.get('style'))
         if m:
-            logger.info("subregion %d: %s", sr, m.groups()[0])
+            logger.debug("subregion %d: %s", sr, m.groups()[0])
         yield from get_shapes(p.get('d'))
         sr += 1
     for p in svg.findall(".//{http://www.w3.org/2000/svg}line"):

femagtools/dxfsl/symmetry.py

@@ -12,6 +12,7 @@ import logging
 import sys
 from femagtools.dxfsl.shape import Element, Line
 from femagtools.dxfsl.area import Area
+import femagtools.dxfsl.area as AREA
 from femagtools.dxfsl.functions import alpha_angle, positive_angle, is_same_angle
 from femagtools.dxfsl.functions import min_angle, max_angle, gcd, point
 from femagtools.dxfsl.functions import less_equal, less, points_are_close
@@ -100,24 +101,25 @@ class Symmetry(object):
         return positive_angle(alpha_angle(self.startangle,
                                           a.get_mid_angle(self.geom.center)))
 
-    def find_symmetry(self):
-        arealist = self.geom.list_of_areas()
-        logger.debug("begin of Symmetry::find_symmetry: %s areas available", len(arealist))
-        if len(arealist) == 0:
-            logger.debug("end of find_symmetry: no areas")
-            return 0
+    def area_list_entry(self, a):
+        return (round(a.get_alpha(self.geom.center), 3),
+                round(a.min_dist, 1),
+                round(a.height, 1),
+                self.calc_mid_angle(a),
+                a)
 
-        logger.debug("startangle=%s, endangle=%s", self.startangle, self.endangle)
+    def build_area_list(self, types=()):
+        arealist = self.geom.list_of_areas()
+        if types:
+            arealist = [a for a in arealist if a.type in types]
 
         areas = []
         for a in arealist:
-            areas.append((round(a.get_alpha(self.geom.center), 3),
-                          round(a.min_dist, 1),
-                          round(a.height, 1),
-                          self.calc_mid_angle(a),
-                          a))
+            areas.append(self.area_list_entry(a))
         areas.sort(reverse=True)
+        return areas
 
+    def build_results(self, areas):
         a0_alpha, a0_min_dist, a0_height, a0_mid_angle, a0 = areas[0]
         equal_areas = [(a0_mid_angle, a0)]
         check_rslt = []
@@ -146,6 +148,86 @@ class Symmetry(object):
         rslt['area'] = a0
         rslt['areasize'] = areasize
         check_rslt.append((areasize, rslt))
+        return check_rslt
+
+    def get_winding_symmetry(self, inside=False):
+        if inside:
+            areas = [self.area_list_entry(a) for a in self.geom.list_of_areas()
+                     if not a.close_to_ag]
+        else:
+            areas = self.build_area_list((AREA.TYPE_WINDINGS,))
+
+        logger.debug("begin of Symmetry::get_winding_symmetry: %s areas available", len(areas))
+        if not areas:
+            logger.debug("end of Symmetry::get_winding_symmetry: no areas")
+            return 0
+
+        check_rslt = self.build_results(areas)
+        logger.debug("%s results available", len(check_rslt))
+        [logger.debug("Result: %s", rslt) for rslt in check_rslt]
+
+        parts, start_delta = self.get_symmetry_parts(check_rslt)
+        if parts <= 1:
+            return 0
+        self.create_cut_lines(parts, start_delta)
+
+        sym = self.geom_part * parts
+        delta = 2*np.pi/sym
+        self.set_symmetry_parameters(self.startangle, parts, delta)
+
+        logger.debug("end of Symmetry::get_winding_symmetry: parts=%s", parts)
+        return parts
+
+    def get_magnet_symmetry(self):
+        areas = self.build_area_list((AREA.TYPE_MAGNET_AIRGAP, AREA.TYPE_MAGNET_RECT,))
+        air = self.build_area_list((AREA.TYPE_AIR,))
+        mag_list = [a for a in self.geom.list_of_areas() if a.is_magnet()]
+        air_list = [a for a in self.geom.list_of_areas() if a.is_air()]
+        sz_list = [a.area_size() for a in self.geom.list_of_areas()]
+        max_sz = max(sz_list)
+        for a in air_list:
+            if a.area_size() < max_sz * 0.005:
+                continue
+            for m in mag_list:
+                if a.is_touching(m):
+                    areas.append(self.area_list_entry(a))
+                    break
+
+        logger.debug("begin of Symmetry::get_magnet_symmetry: %s areas available", len(areas))
+        if not areas:
+            logger.debug("end of Symmetry::get_magnet_symmetry: no areas")
+            return 0
+
+        check_rslt = self.build_results(areas)
+        logger.debug("%s results available", len(check_rslt))
+        [logger.debug("Result: %s", rslt) for rslt in check_rslt]
+        for sz, rslt in check_rslt:
+            if not rslt.get('startdelta', 0.0) == 0.0:
+                return 0  # not proper
+            if rslt.get('halfslice', None):
+                return 0  # not proper
+
+        parts, start_delta = self.get_symmetry_parts(check_rslt)
+        if parts <= 1:
+            return 0
+        self.create_cut_lines(parts, start_delta)
+
+        sym = self.geom_part * parts
+        delta = 2*np.pi/sym
+        self.set_symmetry_parameters(self.startangle, parts, delta)
+
+        logger.debug("end of Symmetry::get_magnet_symmetry: parts=%s", parts)
+        return parts
+
+    def find_symmetry(self):
+        areas = self.build_area_list()
+
+        logger.debug("begin of Symmetry::find_symmetry: %s areas available", len(areas))
+        if not areas:
+            logger.debug("end of Symmetry::find_symmetry: no areas")
+            return 0
+
+        check_rslt = self.build_results(areas)
 
         parts, start_delta = self.get_symmetry_parts(check_rslt)
         if parts < 2:
@@ -156,18 +238,7 @@ class Symmetry(object):
             self.startangle = self.startangle - self.delta_angle_corr
             self.endangle = self.endangle - self.delta_angle_corr
 
-        self.geom.clear_cut_lines()
-        for alpha in self.symmetry_lines(parts,
-                                         self.startangle,
-                                         start_delta,
-                                         self.endangle):
-            plus = self.geom.max_radius / 10
-            min_radius = max(10, self.geom.min_radius - plus)
-            p1 = point(self.geom.center, min_radius, alpha)
-            p2 = point(self.geom.center, self.geom.max_radius + plus, alpha)
-            line = Line(Element(start=p1, end=p2))
-            line.init_attributes(color='green')
-            self.geom.add_cut_line(line)
+        self.create_cut_lines(parts, start_delta)
 
         logger.debug("end of Symmetry::find_symmetry: -> %s", parts)
         return parts
@@ -375,9 +446,6 @@ class Symmetry(object):
 
                     dlist = []
                     x = 0
-                    # logger.info("inx: %s", inx)
-                    # [logger.info("%s deltas: %s", n, d) for n, d in deltas]
-                    # [logger.info("area: %s", m) for m, a in area_list]
 
                     for i in inx:
                         for n in range(x, i):
@@ -833,6 +901,20 @@ class Symmetry(object):
         logger.debug("return %s parts", parts)
         return parts
 
+    def create_cut_lines(self, parts, start_delta):
+        self.geom.clear_cut_lines()
+        for alpha in self.symmetry_lines(parts,
+                                         self.startangle,
+                                         start_delta,
+                                         self.endangle):
+            plus = self.geom.max_radius / 10
+            min_radius = max(10, self.geom.min_radius - plus)
+            p1 = point(self.geom.center, min_radius, alpha)
+            p2 = point(self.geom.center, self.geom.max_radius + plus, alpha)
+            line = Line(Element(start=p1, end=p2))
+            line.init_attributes(color='green')
+            self.geom.add_cut_line(line)
+
     def symmetry_lines(self, parts, startangle, start_delta, endangle):
         logger.debug("begin symmetry_lines from %s to %s with start %s",
                      startangle,
@@ -858,14 +940,17 @@ class Symmetry(object):
             yield start
 
         # Damit man anschliessend ohne Umstände schneiden kann.
-        self.geom.sym_startangle = sym_startangle
-        self.geom.sym_endangle = sym_startangle + delta
+        self.set_symmetry_parameters(sym_startangle, parts, delta)
+        logger.debug("end symmetry_lines")
+
+    def set_symmetry_parameters(self, startangle, parts, delta):
+        self.geom.sym_startangle = startangle
+        self.geom.sym_endangle = startangle + delta
         self.geom.sym_slices = parts
         self.geom.sym_slice_angle = delta
         self.geom.sym_area = Area([], (0,0), 0.0)
         self.geom.sym_area.sym_startangle = self.geom.sym_startangle
         self.geom.sym_area.sym_endangle = self.geom.sym_endangle
-        logger.debug("end symmetry_lines")
 
     def check_symmetry_of_mirror(self, mirror_geom, mirrorangle):
         logger.debug("begin of Symmetry::check_symmetry_of_mirror")

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)