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

femagtools/__init__.py

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

femagtools/dxfsl/area.py

@@ -12,6 +12,7 @@ import numpy as np
 import networkx as nx
 import logging
 from .functions import less_equal, less, greater_equal, greater
+from .functions import greater_angle, less_angle
 from .functions import distance, alpha_angle, alpha_line, min_angle, max_angle
 from .functions import point, line_m, line_n, intersect_point, points_are_close
 from .functions import middle_angle, part_of_circle, is_same_angle
@@ -75,6 +76,10 @@ class Area(object):
         self.start = 0.0
         self.sym_startangle = 0.0
         self.sym_endangle = 0.0
+        self.sym_upper_left_dist = None
+        self.sym_upper_right_dist = None
+        self.sym_lower_left_dist = None
+        self.sym_lower_right_dist = None
         self.sym_type = 0
         self.symmetry = 0
         self.sym_tolerance = sym_tolerance
@@ -674,6 +679,66 @@ class Area(object):
             return True
         return False
 
+    def set_symmetry_parameter(self, center):
+        all_list = [(distance(center, n), alpha_line(center, n))
+                    for n in self.list_of_nodes()]
+        mid = middle_angle(self.min_angle, self.max_angle)
+        left_list = [(d, a) for d, a in all_list if greater_angle(a, mid)]
+        right_list = [(d, a) for d, a in all_list if less_angle(a, mid)]
+        left_list.sort()
+        right_list.sort()
+
+        if left_list:
+            l_low_d, l_low_a = left_list[0]
+            l_up_d, l_up_a = left_list[-1]
+        else:
+            l_low_d = self.min_dist
+            l_up_d = self.max_dist
+        if right_list:
+            r_low_d, r_low_a = right_list[0]
+            r_up_d, r_up_a = right_list[-1]
+        else:
+            r_low_d = self.min_dist
+            r_up_d = self.max_dist
+        self.sym_upper_left_dist = l_up_d
+        self.sym_upper_right_dist = r_up_d
+        self.sym_lower_left_dist = l_low_d
+        self.sym_lower_right_dist = r_low_d
+
+    def is_symmetry_equal(self, area):
+        logger.debug("check area %s -- %s", self.get_id(), area.get_id())
+
+        bad = False
+        if not np.isclose(self.sym_lower_left_dist, area.sym_lower_left_dist,
+                           rtol=5e-1, atol=5e-1):
+            logger.debug("Lower left: %s != %s",
+                         self.sym_lower_left_dist,
+                         area.sym_lower_left_dist)
+            bad = True
+
+        if not np.isclose(self.sym_lower_right_dist, area.sym_lower_right_dist,
+                          rtol=5e-1, atol=5e-1):
+            logger.debug("Lower right: %s != %s",
+                         self.sym_lower_right_dist,
+                         area.sym_lower_right_dist)
+            bad = True
+
+        if not np.isclose(self.sym_upper_left_dist, area.sym_upper_left_dist,
+                          rtol=5e-1, atol=5e-1):
+            logger.debug("Upper left: %s != %s",
+                         self.sym_upper_left_dist,
+                         area.sym_upper_left_dist)
+            bad = True
+
+        if not np.isclose(self.sym_upper_right_dist, area.sym_upper_right_dist,
+                          rtol=5e-1, atol=5e-1):
+            logger.debug("Upper right: %s != %s",
+                         self.sym_upper_right_dist,
+                         area.sym_upper_right_dist)
+            bad = True
+
+        return not bad
+
     def increment(self, a):
         if self.is_identical(a):
             return

femagtools/dxfsl/conv.py

@@ -115,6 +115,10 @@ def main():
                            help='create fsl',
                            dest='write_fsl',
                            action="store_true")
+    argparser.add_argument('--fsl_single',
+                           help='create separate fsl for rotor and stator',
+                           dest='write_fsl_single',
+                           action="store_true")
     argparser.add_argument('-v', '--view',
                            help='show a view only',
                            dest='view',
@@ -242,6 +246,7 @@ def main():
                   show_areas=args.show_areas,
                   small_plots=args.small_plots,
                   write_fsl=args.write_fsl,
+                  write_fsl_single=args.write_fsl_single,
                   write_png=args.write_png,
                   write_id=args.write_id,
                   debug_mode=args.debugger,

femagtools/dxfsl/converter.py

@@ -335,6 +335,7 @@ def convert(dxfile,
             show_areas=False,
             small_plots=False,
             write_fsl=True,
+            write_fsl_single=False,
             write_png=False,
             write_id=False,
             full_model=False,
@@ -388,6 +389,9 @@ def convert(dxfile,
         split_ini = False
         split_cpy = split
 
+    if write_fsl_single:
+        write_fsl = True
+
     try:
         if input_file.suffix in ['.fem', '.FEM']:
             from .femparser import femshapes
@@ -719,6 +723,14 @@ def convert(dxfile,
             fslrenderer = FslRenderer(basename, mtype)
             inner = fslrenderer.render(machine_inner, inner=True)
             outer = fslrenderer.render(machine_outer, outer=True)
+            if write_fsl_single:
+                inner_single = fslrenderer.render(machine_inner, inner=True,
+                                                  standalone=True)
+                outer_single = fslrenderer.render(machine_outer, outer=True,
+                                                  standalone=True)
+            else:
+                inner_single = None
+                outer_single = None
             if full_model:
                 params['num_sl_gen'] = params.get('tot_num_slot', 0)
             params['agndst'] = agndst(params.get('da1'),
@@ -729,10 +741,18 @@ def convert(dxfile,
 
             if params['external_rotor']:
                 conv['fsl_rotor'] = outer
+                if outer_single:
+                    conv['fsl_rotor_single'] = outer_single
                 conv['fsl_stator'] = inner
+                if inner_single:
+                    conv['fsl_stator_single'] = inner_single
             else:
                 conv['fsl_rotor'] = inner
+                if inner_single:
+                    conv['fsl_rotor_single'] = inner_single
                 conv['fsl_stator'] = outer
+                if outer_single:
+                    conv['fsl_stator_single'] = outer_single
 
             conv['fsl'] = fslrenderer.render_main(
                 machine_inner, machine_outer,
@@ -875,11 +895,24 @@ def convert(dxfile,
     if write_fsl:
         logger.debug("Write fsl")
         if conv and conv['fsl']:
-            with io.open(basename + '.fsl', 'w', encoding='utf-8') as f:
+            with io.open(basename + '.fsl', 'w',
+                         encoding='utf-8') as f:
                 f.write('\n'.join(conv['fsl']))
         else:
             logger.warning("No fsl data available")
 
+        if conv:
+            if conv.get('fsl_rotor_single', None):
+                with io.open(basename + '_ROTOR.fsl', 'w',
+                             encoding='utf-8') as f:
+                    f.write('\n'.join(conv['fsl_rotor_single']))
+                del conv['fsl_rotor_single']
+            if conv.get('fsl_stator_single', None):
+                with io.open(basename + '_STATOR.fsl', 'w',
+                             encoding='utf-8') as f:
+                    f.write('\n'.join(conv['fsl_stator_single']))
+                del conv['fsl_stator_single']
+
     conv['name'] = basename
     t = timer.stop("-- all done in %0.4f seconds --", info=True)
     journal.put('time_total', t)

femagtools/dxfsl/functions.py

@@ -85,16 +85,24 @@ def alpha_angle(startangle, endangle):
     return angle - 2.0*np.pi
 
 
-def max_angle(alpha1, alpha2):
+def less_angle(alpha1, alpha2):
     angle = alpha_angle(alpha1, alpha2)
-    if angle < np.pi or angle > 2.0*np.pi:
-        return alpha2
-    return alpha1
+    return (angle < np.pi or angle > 2.0*np.pi)
 
 
-def min_angle(alpha1, alpha2):
+def greater_angle(alpha1, alpha2):
     angle = alpha_angle(alpha1, alpha2)
-    if angle < np.pi or angle > 2.0*np.pi:
+    return not (angle < np.pi or angle > 2.0*np.pi)
+
+
+def max_angle(alpha1, alpha2):
+    if greater_angle(alpha1, alpha2):
+        return alpha1
+    return alpha2
+
+
+def min_angle(alpha1, alpha2):
+    if less_angle(alpha1, alpha2):
         return alpha1
     return alpha2
 

femagtools/dxfsl/geom.py

@@ -1986,7 +1986,7 @@ class Geometry(object):
                                startangle=0.0,
                                endangle=np.pi/2)
 
-        elif np.isclose(width, height*2, self.rtol, self.atol):
+        elif np.isclose(width, height*2, rtol=1e-2, atol=1e-2):
             radius = width/2
             self.set_center([mm[1]-height, mm[2]])
             logger.info("check for half machine")
@@ -2005,7 +2005,7 @@ class Geometry(object):
                                startangle=np.pi,
                                endangle=0.0)
 
-        elif np.isclose(width*2, height, self.rtol, self.atol):
+        elif np.isclose(width*2, height, rtol=1e-2, atol=1e-2):
             radius = width
             logger.info("check for half machine")
             self.set_center([mm[1], mm[3]-width])
@@ -2409,31 +2409,31 @@ class Geometry(object):
         logger.debug("end check_airgap: return %s", len(area_id_list) > 1)
         return len(area_id_list) > 1  # bad
 
-    def is_border_line(self, center, startangle, endangle, e, atol):
+    def is_border_line(self, center, startangle, endangle, e, rtol=1e-3, atol=1e-3):
         if isinstance(e, Line):
             if np.isclose(startangle, endangle):
                 return False  # full
 
             if points_are_close(center, e.p1):
                 angle_p2 = alpha_line(center, e.p2)
-                if np.isclose(startangle, angle_p2, 1e-3, atol):
+                if np.isclose(startangle, angle_p2, rtol=rtol, atol=atol):
                     return True
-                return np.isclose(endangle, angle_p2, 1e-3, atol)
+                return np.isclose(endangle, angle_p2, rtol=rtol, atol=atol)
 
             if points_are_close(center, e.p2):
                 angle_p1 = alpha_line(center, e.p1)
-                if np.isclose(startangle, angle_p1, 1e-3, atol):
+                if np.isclose(startangle, angle_p1, rtol=rtol, atol=atol):
                     return True
-                return np.isclose(endangle, angle_p1, 1e-3, atol)
+                return np.isclose(endangle, angle_p1, rtol=rtol, atol=atol)
 
             angle_p1 = alpha_line(center, e.p1)
-            if np.isclose(startangle, angle_p1, 1e-3, atol):
+            if np.isclose(startangle, angle_p1, rtol=rtol, atol=atol):
                 angle_p2 = alpha_line(center, e.p2)
-                return np.isclose(startangle, angle_p2, 1e-3, atol)
+                return np.isclose(startangle, angle_p2, rtol=rtol, atol=atol)
 
-            if np.isclose(endangle, angle_p1, 1e-3, atol):
+            if np.isclose(endangle, angle_p1, rtol=rtol, atol=atol):
                 angle_p2 = alpha_line(center, e.p2)
-                return np.isclose(endangle, angle_p2, 1e-3, atol)
+                return np.isclose(endangle, angle_p2, rtol=rtol, atol=atol)
         return False
 
     def get_gaplist(self, center):
@@ -2457,7 +2457,7 @@ class Geometry(object):
         """
         gaplist = []
         for e in self.elements(Shape):
-            if not self.is_border_line(center, startangle, endangle, e, atol):
+            if not self.is_border_line(center, startangle, endangle, e, atol=atol):
                 gaplist += [e.minmax_from_center(center)]
             else:
                 min_r, max_r = e.minmax_from_center(center)

femagtools/dxfsl/journal.py

@@ -18,7 +18,7 @@ logger = logging.getLogger('femagtools.journal')
 journal = None
 
 #############################
-#           concat          #
+#          journal          #
 #############################
 
 

femagtools/dxfsl/symmetry.py

@@ -102,6 +102,7 @@ class Symmetry(object):
                                           a.get_mid_angle(self.geom.center)))
 
     def area_list_entry(self, a):
+        a.set_symmetry_parameter(self.geom.center)
         return (round(a.get_alpha(self.geom.center), 3),
                 round(a.min_dist, 1),
                 round(a.height, 1),
@@ -124,19 +125,34 @@ class Symmetry(object):
         equal_areas = [(a0_mid_angle, a0)]
         check_rslt = []
         for a1_alpha, a1_min_dist, a1_height, a1_mid_angle, a1 in areas[1:]:
-            if self.equal_area(a0_min_dist, a0_height, a0_alpha,
-                               a1_min_dist, a1_height, a1_alpha,
-                               rtol=0.001, atol=0.05):
+            if (self.equal_area(a0_min_dist, a0_height, a0_alpha,
+                                a1_min_dist, a1_height, a1_alpha,
+                                rtol=0.001, atol=0.05)):
                 a0_min_dist = (a0_min_dist + a1_min_dist) / 2
                 a0_height = (a0_height + a1_height) / 2
                 a0_alpha = (a0_alpha + a1_alpha) / 2
                 equal_areas.append((a1_mid_angle, a1))
             else:
-                rslt = self.check_delta(equal_areas)
-                areasize = a0.area_size()
-                rslt['area'] = a0
-                rslt['areasize'] = areasize
-                check_rslt.append((areasize, rslt))
+                # alpha Wechsel
+                id_list = []
+                for i in range(len(equal_areas)):
+                    mid_angle0, area0 = equal_areas[i]
+                    if area0.get_id() in id_list:
+                        continue
+                    equal_areas_check = [(mid_angle0, area0)]
+                    for mid_angle1, area1 in equal_areas[i+1:]:
+                        if area1.get_id() in id_list:
+                            continue
+                        if area0.is_symmetry_equal(area1):
+                            equal_areas_check.append((mid_angle1, area1))
+                            id_list.append(area1.get_id())
+
+                    rslt = self.check_delta(equal_areas_check)
+                    areasize = a0.area_size()
+                    rslt['area'] = a0
+                    rslt['areasize'] = areasize
+                    check_rslt.append((areasize, rslt))
+
                 equal_areas = [(a1_mid_angle, a1)]
                 a0_min_dist = a1_min_dist
                 a0_height = a1_height
@@ -154,6 +170,7 @@ class Symmetry(object):
         if inside:
             areas = [self.area_list_entry(a) for a in self.geom.list_of_areas()
                      if not a.close_to_ag]
+            areas.sort(reverse=True)
         else:
             areas = self.build_area_list((AREA.TYPE_WINDINGS,))
 
@@ -228,6 +245,8 @@ class Symmetry(object):
             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 < 2:
@@ -248,6 +267,7 @@ class Symmetry(object):
         result = {'areas': len(area_list),
                   'startdelta': 0.0,
                   'slices': None}
+        result['area_id_list'] = [a.get_id() for m, a in area_list]
         if not area_list:
             logger.debug("end of check_delta: no areas")
             return result

femagtools/femag.py

@@ -27,6 +27,7 @@ import femagtools.fsl
 import femagtools.config
 import femagtools.ecloss
 import femagtools.forcedens
+import femagtools.zmq
 
 from femagtools import ntib
 
@@ -180,15 +181,22 @@ class BaseFemag(object):
     def copy_winding_file(self, name, wdg):
         wdg.write(name, self.workdir)
 
-    def copy_magnetizing_curves(self, model, dir=None, recsin=''):
+    def copy_magnetizing_curves(self, model, dir=None, recsin='', feloss=''):
         """extract mc names from model and write files into workdir or dir if given
 
         Return:
             list of extracted mc names (:obj:`list`)
         """
         dest = dir if dir else self.workdir
+        if isinstance(feloss, (int, float)):
+            try:
+                feloss = {1: 'jordan', 11: 'bertotti'}[int(feloss)]
+            except KeyError:
+                feloss = ''
         return [self.magnetizingCurves.writefile(m[0], dest,
-                                                 fillfac=m[1], recsin=recsin)
+                                                 fillfac=m[1],
+                                                 recsin=recsin,
+                                                 feloss=feloss)
                 for m in model.set_magcurves(
             self.magnetizingCurves, self.magnets)]
 
@@ -212,9 +220,11 @@ class BaseFemag(object):
         self.model = femagtools.model.MachineModel(machine)
         self.modelname = self.model.name
         recsin = ''
+        feloss = ''
         if simulation:
             recsin = simulation.get('recsin', '')
-        self.copy_magnetizing_curves(self.model, recsin=recsin)
+            feloss = simulation.get('calc_fe_loss', '')
+        self.copy_magnetizing_curves(self.model, recsin=recsin, feloss=feloss)
         try:
             if 'wdgdef' in self.model.winding:
                 self.model.winding['wdgfile'] = self.create_wdg_def(
@@ -429,12 +439,15 @@ class BaseFemag(object):
         """
         Read the modelname from the Femag Log file
         """
-        with open(os.path.join(self.workdir, 'FEMAG-FSL.log')) as f:
-            for l in f:
-                if l.startswith('New model') or l.startswith('Load model'):
-                    return l.split('"')[1]
+        try:
+            with open(os.path.join(self.workdir, 'FEMAG-FSL.log')) as f:
+                for l in f:
+                    if l.startswith('New model') or l.startswith('Load model'):
+                        return l.split('"')[1]
+        except FileNotFoundError:
+            pass
 
-        raise ValueError(f"Model not found in {self.workdir}/'FEMAG-FSL.log'")
+        return list(pathlib.Path(self.workdir).glob('*.PROT'))[0].stem
 
     def readResult(self, simulation, bch=None):
         if simulation:
@@ -715,55 +728,6 @@ class FemagTask(threading.Thread):
         self.returncode = self.proc.wait()
 
 
-class SubscriberTask(threading.Thread):
-    def __init__(self, port, host, notify):
-        threading.Thread.__init__(self)
-        context = zmq.Context.instance()
-        self.subscriber = context.socket(zmq.SUB)
-        if not host:
-            host = 'localhost'
-        self.subscriber.connect(f'tcp://{host}:{port}')
-        self.subscriber.setsockopt(zmq.SUBSCRIBE, b'')
-        self.controller = zmq.Context.instance().socket(zmq.PULL)
-        self.controller_url = 'inproc://publisher'
-        self.controller.bind(self.controller_url)
-        self.poller = zmq.Poller()
-        self.poller.register(self.subscriber, zmq.POLLIN)
-        self.poller.register(self.controller, zmq.POLLIN)
-        self.logger = logger
-        self.notify = notify
-
-    def stop(self):
-        socket = zmq.Context.instance().socket(zmq.PUSH)
-        socket.connect(self.controller_url)
-        socket.send(b"quit")
-        socket.close()
-
-    def run(self):
-        self.logger.info("subscriber is ready")
-        while True:
-            socks = dict(self.poller.poll())
-            if socks.get(self.subscriber) == zmq.POLLIN:
-                try:
-                    response = self.subscriber.recv_multipart()
-                    # Sometimes femag send messages with only len = 1. These messages must be ignored
-                    if len(response) < 2:
-                        continue
-                    self.notify([s.decode('latin1') for s in response])
-
-                except Exception:
-                    self.logger.error(
-                        "error in subscription message processing", exc_info=True)
-
-            if socks.get(self.controller) == zmq.POLLIN:
-                req = self.controller.recv()
-                self.logger.info("subscriber %s", req)
-                break
-        self.subscriber.close()
-        self.controller.close()
-        self.logger.debug("subscriber stopped")
-
-
 class ZmqFemag(BaseFemag):
     """Invoke and control execution of FEMAG with ZeroMQ
 
@@ -838,8 +802,8 @@ class ZmqFemag(BaseFemag):
         """attaches a notify function"""
         logger.info("Subscribe on '%s' port %d", self.femaghost, self.port+1)
         if self.subscriber is None:
-            self.subscriber = SubscriberTask(
-                self.port+1, self.femaghost, notify)
+            self.subscriber = femagtools.zmq.SubscriberTask(
+                port=self.port+1, host=self.femaghost, notify=notify)
             self.subscriber.start()
         else:
             # reattach?
@@ -1149,6 +1113,38 @@ class ZmqFemag(BaseFemag):
             logger.warning(response[0])
         return [s.decode('latin1') for s in response]
 
+    def airgap_flux_density(self, pmod):
+        # try to read bag.dat
+        agr = self.getfile("bag.dat")
+        status = json.loads(agr[0])['status']
+        if status == 'ok':
+            datfile = os.path.join(self.workdir, 'bag.dat')
+            with open(datfile, 'wb') as bagfile:
+                bagfile.write(agr[1])
+            agi = ag.read(datfile, pmod)
+        else:
+            import numpy as np
+            # try to read model file (TODO download with getfile)
+            nc = self.read_nc()
+            ag_elmnts = nc.airgap_center_elements
+            logger.info("Airgap elements %d scale_factor %f",
+                        len(ag_elmnts), nc.scale_factor())
+            if len(ag_elmnts) < 1:
+                raise ValueError("Missing airgap elements")
+            scf = 360/nc.scale_factor()/ag_elmnts[-1].center[0]
+            pos = np.array([e.center[0]*scf for e in ag_elmnts])
+            bxy = np.array([e.flux_density() for e in ag_elmnts]).T
+            if np.max(bxy[0]) > np.max(bxy[1]):
+                agi = ag.fft(pos, bxy[0], pmod)
+            else:
+                agi = ag.fft(pos, bxy[1], pmod)
+        return dict(Bamp=agi['Bamp'],
+                    phi0=agi['phi0'],
+                    angle=agi['pos'],
+                    angle_fft=agi['pos'],
+                    B=agi['B'],
+                    B_fft=agi['B_fft'])
+
     def interrupt(self):
         """send push message to control port to stop current calculation"""
         context = zmq.Context.instance()
@@ -1165,7 +1161,7 @@ class ZmqFemag(BaseFemag):
         wdg.write(name, self.workdir)
         self.upload(os.path.join(self.workdir, name+'.WID'))
 
-    def copy_magnetizing_curves(self, model, dir=None, recsin=''):
+    def copy_magnetizing_curves(self, model, dir=None, recsin='', feloss=''):
         """extract mc names from model and write files into workdir or dir if given
            and upload to Femag
 
@@ -1175,9 +1171,16 @@ class ZmqFemag(BaseFemag):
         dest = dir if dir else self.workdir
         mc_names = [m for m in model.set_magcurves(
             self.magnetizingCurves, self.magnets)]
+        if isinstance(feloss, (int, float)):
+            try:
+                feloss = {1: 'jordan', 11: 'bertotti'}[int(feloss)]
+            except KeyError:
+                feloss = ''
         for m in mc_names:
             f = self.magnetizingCurves.writefile(m[0], dest,
-                                                 fillfac=m[1], recsin=recsin)
+                                                 fillfac=m[1],
+                                                 recsin=recsin,
+                                                 feloss=feloss)
             self.upload(os.path.join(dest, f))
         return mc_names
 

femagtools/fsl.py

@@ -556,7 +556,7 @@ class Builder:
         if 'fsl_rotor' in conv:
             self.fsl_rotor = True
             th_props = ['']
-            logger.info(model['magnet'])
+            logger.debug(model['magnet'])
             if hasattr(model, 'magnet'):
                 if model['magnet'].get('thcond', 0):
                     th_props = [f'rotor_density = {model["magnet"]["density"]}',
@@ -730,7 +730,7 @@ class Builder:
         custom_fefunc = ['']
         if pfefunc:
             sim['loss_funct'] = 1 # 3?
-            if pfefunc == 'bertotti' or 'modified_steinmetz':
+            if pfefunc in ('bertotti', 'modified_steinmetz'):
                 custom_fefunc = self.__render(sim['PVFE_FSL'], pfefunc)
             else:
                 custom_fefunc = pfefunc.split('\n')
@@ -750,6 +750,9 @@ class Builder:
             revert_displ = self.create_displ_stator_rotor(
                 sim['eccentricity'])
 
+        if sim.get('calculationMode') == 'pm_sym_f_cur':
+            if 'nload_ex_cur' in sim.keys():  # convert obsolete key
+                sim['noload_ex_cur'] = sim.pop('nload_ex_cur')
         felosses = custom_fefunc + self.create_fe_losses(sim)
         fslcalc = (displ_stator_rotor
                    + self.__render(sim, sim.get('calculationMode'))

femagtools/isa7.py

@@ -815,8 +815,9 @@ class Isa7(object):
                             airgap_positions.append(axy[0][0])
                         self.airgap_center_elements.append(se.elements)
 
-            if len(self.airgap_center_elements) == 1:
-                self.airgap_center_elements = self.airgap_center_elements[0]
+            if self.airgap_center_elements:
+                # TODO check airgap center
+                self.airgap_center_elements = self.airgap_center_elements[-1]
                 if horiz:
                     airgap_positions.append(np.min(nxy[:, 1]))
                 else: