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

femagtools/dxfsl/geom.py

@@ -235,6 +235,9 @@ def single_path(edges):
 
 nodes_filecount = 0
 
+TYPE_UNDEFINED = 0
+TYPE_ROTOR = 1
+TYPE_STATOR = 2
 
 class Geometry(object):
     """collection of connected shapes"""
@@ -252,6 +255,7 @@ class Geometry(object):
                  delete=False,
                  adjust=False,
                  main=False,
+                 type=TYPE_UNDEFINED,
                  debug=False):
         self._name = ''
         self.kind = ''
@@ -260,6 +264,7 @@ class Geometry(object):
         self.end_corners = []
         self.sym_part = 0
         self.sym_counterpart = 0
+        self.sym_type = type
         self.sym_slices = 0
         self.sym_slice_angle = 0.0
         self.alfa = 0.0
@@ -440,10 +445,12 @@ class Geometry(object):
                         is_inner=self.is_inner,
                         is_outer=self.is_outer,
                         rtol=self.rtol,
-                        atol=self.atol)
+                        atol=self.atol,
+                        type=self.sym_type)
         geom.alfa = correct_alpha
         geom.kind = self.kind
         geom.sym_part = self.sym_part
+        geom.sym_type = self.sym_type
         return geom
 
     def log_geom(self):
@@ -861,6 +868,12 @@ class Geometry(object):
     def start_max_corner(self, i):
         return self.start_corners[-1][i]
 
+    def get_start_airgap_node(self):
+        if self.is_inner:
+            return self.start_corners[-1]
+        else:
+            return self.start_corners[0]
+
     def dist_start_max_corner(self):
         logger.debug("begin of dist_start_max_corner")
         logger.debug("start corners: %s", self.start_corners)
@@ -868,16 +881,21 @@ class Geometry(object):
         logger.debug("end of dist_start_max_corner: %s", d)
         return d
 
-    def dist_end_max_corner(self):
+    def dist_end_max_corner(self, mirrored=True):
         logger.debug("begin of dist_end_max_corner")
         logger.debug("end corners: %s", self.end_corners)
 
-        if self.is_mirrored():
+        if self.is_mirrored() and mirrored:
             return self.dist_start_max_corner()
         d = distance(self.center, self.end_corners[-1])
         logger.debug("end of dist_end_max_corner: %s", d)
         return d
 
+    def max_corners_match(self):
+        d1 = self.dist_start_max_corner()
+        d2 = self.dist_end_max_corner(mirrored=False)
+        return np.isclose(d1, d2, rtol=1e-3, atol=1e-3)
+
     def dist_start_min_corner(self):
         logger.debug("begin of dist_start_min_corner")
         logger.debug("start corners: %s", self.start_corners)
@@ -885,16 +903,24 @@ class Geometry(object):
         logger.debug("end of dist_start_min_corner: %s", d)
         return d
 
-    def dist_end_min_corner(self):
+    def dist_end_min_corner(self, mirrored=True):
         logger.debug("begin of dist_end_min_corner")
         logger.debug("end corners: %s", self.end_corners)
 
-        if self.is_mirrored():
+        if self.is_mirrored() and mirrored:
             return self.dist_start_min_corner()
         d = distance(self.center, self.end_corners[0])
         logger.debug("end of dist_end_min_corner: %s", d)
         return d
 
+    def min_corners_match(self):
+        d1 = self.dist_start_min_corner()
+        d2 = self.dist_end_min_corner(mirrored=False)
+        return np.isclose(d1, d2, rtol=1e-3, atol=1e-3)
+
+    def min_max_corners_match(self):
+        return self.min_corners_match() and self.max_corners_match()
+
     def get_start_airgap_corner(self):
         if self.is_inner:
             p = (self.max_radius, 0.0)
@@ -1146,9 +1172,12 @@ class Geometry(object):
             nx.set_edge_attributes(self.g, False, 1)
             nx.set_edge_attributes(self.g, False, 2)
 
-    def create_list_of_areas(self, main=False):
+    def create_list_of_areas(self, main=False, delete=False):
         """ return list of areas for each node and their neighbors
         """
+        if delete:  # clear list of areas
+            self.area_list = []
+
         if len(self.area_list) > 0:
             logger.debug("area list already available")
             # list already available
@@ -1553,7 +1582,8 @@ class Geometry(object):
                         concatenate=concatenate,
                         connect=connect,
                         delete=delete_appendices,
-                        split=split)
+                        split=split,
+                        type=self.sym_type)
         geom.with_center_node = self.with_center_node
 
         logger.debug('end copy_shape')
@@ -1614,7 +1644,8 @@ class Geometry(object):
                         split=split,
                         concatenate=concatenate,
                         connect=connect,
-                        adjust=adjust)
+                        adjust=adjust,
+                        type=self.sym_type)
 
     def is_new_angle(self, alpha_list, alpha):
         for a in alpha_list:
@@ -1704,6 +1735,13 @@ class Geometry(object):
     def symmetry_endangle(self):
         return self.sym_area.sym_endangle
 
+    def rotate_symmetry_parameters(self):
+        self.sym_startangle += self.sym_slice_angle
+        self.sym_endangle += self.sym_slice_angle
+        if self.sym_area:
+            self.sym_area.sym_startangle = self.sym_startangle
+            self.sym_area.sym_endangle = self.sym_endangle
+
     def get_symmetry_copies(self):
         if self.sym_counterpart == 0:
             return int(self.sym_part)
@@ -2753,7 +2791,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 +2855,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)
 
@@ -2957,12 +2996,22 @@ class Geometry(object):
         self.sym_counterpart = 1
         self.sym_part = 2
 
+    def force_to_be_rotor(self):
+        self.sym_type = TYPE_ROTOR
+
+    def force_to_be_stator(self):
+        self.sym_type = TYPE_STATOR
+
     def is_rotor(self):
+        if self.sym_type != TYPE_UNDEFINED:
+            return self.sym_type == TYPE_ROTOR
         if self.sym_counterpart:
             return self.sym_part < self.sym_counterpart
         return False
 
     def is_stator(self):
+        if self.sym_type != TYPE_UNDEFINED:
+            return self.sym_type == TYPE_STATOR
         if self.sym_counterpart:
             return self.sym_part > self.sym_counterpart
         return False
@@ -3095,6 +3144,16 @@ class Geometry(object):
                     for e in elist:
                         e.init_attributes('lightblue', 'no_fsl')
 
+    def set_subregion_parameters(self,
+                                 startangle,
+                                 endangle):
+        for a in self.list_of_areas():
+            a.set_subregion_parameters(self.is_inner,
+                                       self.min_radius,
+                                       self.max_radius,
+                                       startangle,
+                                       endangle)
+
     def search_subregions(self, startangle, endangle, EESM, single=False):
         if self.is_stator():
             self.search_stator_subregions(startangle,
@@ -3554,22 +3613,33 @@ class Geometry(object):
             return
         elements = []
         for a in areas:
-            elements += a.elements()
-        geom = Geometry(elements, center=self.center)
+            elements += a.copy_of_elements()
+        geom = Geometry(elements, center=self.center, type=self.sym_type)
+        geom.create_list_of_areas()
+        mag_areas = geom.list_of_areas()
+
         builder = AreaBuilder(geom=geom)
-        if builder.create_area_groups(areas):
+        if builder.create_area_groups(mag_areas):
             return  # bad
         group_list = builder.area_list
-        # for debugging
-        # self.areagroup_list = group_list
+
         for group in group_list:
             if not group.is_magnet_rectangle():
                 logger.debug("Warning: group is not a rectangle")
             group.set_type(AREA.TYPE_MAGNET_RECT)
             phi = group.get_magnet_orientation()
             for a in group.areas_of_group:
-                logger.debug("Replace phi %s by %s", a.phi, phi)
                 a.phi = phi
+                p = a.get_best_point_inside(geom)
+                phi_set = False
+                for area in areas:
+                    if area.the_point_is_inside_area(p):
+                        logger.debug("Replace phi %s by %s", area.phi, phi)
+                        area.phi = phi
+                        phi_set = True
+                        break
+                if not phi_set:
+                    logger.warning("___MAGNET PHI NOT SET. AREA NOT FOUND IN GEOMETRY___")
 
     def search_unknown_subregions(self):
         logger.debug("begin of search_unknown_subregions")
@@ -3613,7 +3683,7 @@ class Geometry(object):
     def windings_in_the_middle(self, midangle):
         wdg_areas = [a for a in self.list_of_areas()
                      if a.is_winding()]
-        logger.info("%s windings in geom", len(wdg_areas))
+        logger.debug("%s windings in geom", len(wdg_areas))
         for a in wdg_areas:
             if greater(a.max_angle, midangle) and \
                less(a.min_angle, midangle):
@@ -3635,16 +3705,25 @@ 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 num_of_magnets(self):
+        return self.num_areas_of_type((AREA.TYPE_MAGNET_AIRGAP,
+                                       AREA.TYPE_MAGNET_RECT,))
 
     def area_close_to_endangle(self, type):
         return len([area for area in self.list_of_areas()
@@ -4141,61 +4220,18 @@ class Geometry(object):
                 return True
         return False
 
-    def get_inner_airgap_line(self):
-        logger.debug("begin of get_inner_airgap_line")
-
-        if not self.is_inner:
-            logger.debug("end of get_inner_airgap_line: not inner")
-            return [], []
-        for a in self.area_list:
-            logger.debug("%s", a)
-        area = [a for a in self.area_list if a.close_to_ag_endcorner]
-        if len(area) != 1:
-            logger.debug("end of get_inner_airgap_line: %s areas found", len(area))
-            return [], []
-
-        end_corner = self.end_corners[-1]
-        logger.debug("END CORNER %s", end_corner)
-        nodes = [n for n in area[0].list_of_nodes()]
-        if not nodes:
-            logger.debug("end of get_inner_airgap_line: no nodes found")
-            return [], []
-        n1 = nodes[0]
-        if points_are_close(end_corner, n1):
-            n2 = nodes[-1]
-        else:
-            n2 = n1
-            for n1 in nodes[1:]:
-                if points_are_close(end_corner, n1):
-                    break
-                n2 = n1
-
-        if not points_are_close(end_corner, n1):
-            logger.debug("end of get_inner_airgap_line: not close to endcorner")
-            return [], []
-
-        start_corner = self.start_corners[-1]
-
-        logger.debug("EDGE FOUND: %s - %s", n1, n2)
-        nodes = [n1, n2]
-        info = self.get_edge_info(n1, n2)
-        elements = [info.get('element', None)]
-        while not points_are_close(start_corner, n2):
-            info = self.next_edge_lefthand_side(info)
-            if not info:
-                return []
-            n2 = info['n2']
-            nodes.append(n2)
-            elements.append(info.get('element', None))
-
-        logger.debug("end of get_inner_airgap_line #%s", len(nodes))
-        return nodes, elements
-
     def create_inner_corner_areas(self, startangle, endangle):
-        self.set_edge_attributes()
+        builder = AreaBuilder(geom=self)
+        return builder.create_inner_corner_auxiliary_areas(startangle, endangle)
+
+    def close_outer_winding_areas(self):
+        logger.debug("begin close_outer_winding_areas(%s areas)",
+                     len(self.area_list))
 
         builder = AreaBuilder(geom=self)
-        builder.create_inner_corner_auxiliary_areas(startangle, endangle)
+        rslt = builder.close_outer_winding_areas()
+        logger.debug("end close_outer_winding_areas (%s)", rslt)
+        return rslt
 
     def repair_border_line(self, nodes):
         logger.debug("begin repair_border_line")
@@ -4206,9 +4242,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 +4276,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 with Nodes Start=%s,  End=%s", len(start_nodes), len(end_nodes))
+        logger.debug("End Nodes")
+        [logger.debug(" --> %s", x) for x in end_nodes]
 
-        nodes = [n for d, n in start_nodes]
-        start_rot_nodes = self.rotate_nodes(alpha, 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
 
-        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
+        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
 
-        logger.debug("end of create_boundery_nodes")
-        return
+        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
+
+        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):
@@ -4354,78 +4433,34 @@ class Geometry(object):
             points += pts
         return points
 
-    def create_inner_corner_auxiliary_areas(self):
-        start_cp, start_exists = self.get_start_airgap_corner()
-        end_cp, end_exists = self.get_end_airgap_corner()
-        if start_exists and end_exists:
-            return
-        logger.debug("*** Corner Auxiliary Areas ***")
-        airgap_line, airgap_el = self.get_inner_airgap_line()
-        if not airgap_el:
-            logger.debug("no airgapline found")
-            return
-
-        logger.debug("airgapline found !!")
-        airgap_nodes = [n for n in airgap_line[1:]]
-        del airgap_nodes[-1]
+    def mirror_all_areas(self, mirrorangle):
+        axis_p = point(self.center, self.max_radius, mirrorangle)
+        axis_m = line_m(self.center, axis_p)
+        axis_n = line_n(self.center, axis_m)
 
-        if not start_exists:
-            cp = self.start_corners[-1]
-            logger.debug("Start Corner: %s -- %s", cp, start_cp)
-            start_line = Line(Element(start=cp, end=start_cp),
-                              color='red',
-                              linestyle='dotted')
-
-            start_cp = start_line.node2(ndec)
-            for n in airgap_nodes:
-                ag_line = Line(Element(start=start_cp, end=n))
-                points = self.get_intersection_points(airgap_el, ag_line, n)
-                if not points:  # no intersection
-                    d = distance(self.center, n)
-                    if np.isclose(d, self.max_radius):
-                        self.add_arc(start_cp, n, self.center, self.max_radius,
-                                     color='red',
-                                     linestyle='dotted')
-                    else:
-                        self.add_line(start_cp, n,
-                                      color='red',
-                                      linestyle='dotted')
-                    self.add_element(start_line,
-                                     rtol=self.rtol,
-                                     atol=self.atol)
-                    self.create_and_append_area(start_cp, n)
-                    self.start_corners = self.get_corner_nodes(self.center,
-                                                               0.0)
-                    break
+        def add_element(e):
+            n = self.find_nodes(e.start(), e.end())
+            if not self.has_edge(n[0], n[1]):
+                self.add_edge(n[0], n[1], e)
 
-        if not end_exists:
-            cp = self.end_corners[-1]
-            logger.debug("End Corner: %s -- %s", cp, end_cp)
-            end_line = Line(Element(start=cp, end=end_cp),
-                            color='red',
-                            linestyle='dotted')
-            end_cp = end_line.node2(ndec)
-            airgap_nodes.reverse()
-            for n in airgap_nodes:
-                ag_line = Line(Element(start=end_cp, end=n))
-                points = self.get_intersection_points(airgap_el, ag_line, n)
-                if not points:  # no intersection
-                    d = distance(self.center, n)
-                    if np.isclose(d, self.max_radius):
-                        self.add_arc(n, end_cp, self.center, self.max_radius,
-                                     color='red',
-                                     linestyle='dotted')
-                    else:
-                        self.add_line(end_cp, n,
-                                      color='red',
-                                      linestyle='dotted')
-                    self.add_element(end_line,
-                                     rtol=self.rtol,
-                                     atol=self.atol)
-                    self.create_and_append_area(n, end_cp)
-                    self.end_corners = self.get_corner_nodes(self.center,
-                                                             self.alfa)
-                    break
+        area_list = []
+        for a in self.area_list:
+            area = a.mirror_area(self.center, axis_m, axis_n)
+            area_list.append(area)
+            for e in area.elements():
+                add_element(e)
+        self.area_list += area_list
+
+    def check_airgap_connecting_nodes(self, geom, startangle, endangle):
+        logger.info("check_airgap_connecting_nodes")
+
+        start_node_in = self.get_start_airgap_node()
+        start_node_out =  geom.get_start_airgap_node()
+        angle_in = alpha_line(self.center, start_node_in)
+        angle_out = alpha_line(self.center, start_node_out)
+        if np.isclose(angle_in, angle_out):
+            return
+        logger.warning("WARNING: airgap connecting nodes do not aline")
 
     def print_nodes(self):
         print("=== List of Nodes ({}) ===".format(self.number_of_nodes()))