femagtools 1.8.18__py3-none-any.whl → 1.8.20__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.8.18'
+__version__ = '1.8.20'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2023-2025 Gamma Technology'

femagtools/bch.py

@@ -271,7 +271,7 @@ class Reader:
             return self.flux[0]['displ'][1]-self.flux[0]['displ'][0]
         return None
 
-    def read(self, content):
+    def read(self, content, **kwargs):
         """read bch file
 
         Args:
@@ -297,7 +297,10 @@ class Reader:
                     if k == title2[:len(k)]:
                         title = title2[:len(k)]
             if title in self.dispatch:
-                self.dispatch[title](self, s)
+                if title == 'Airgap Induction Br':
+                    self.dispatch[title](self, s, kwargs.get('ignore_airgap_induction_with_c_step_section', True))
+                else:
+                    self.dispatch[title](self, s)
 
         if len(self.weights) > 0:
             w = list(zip(*self.weights))
@@ -887,7 +890,7 @@ class Reader:
             self.flux_fft[self.wdg] = []
         self.flux_fft[self.wdg].append(flux_fft)
 
-    def __read_airgapInduction(self, content):
+    def __read_airgapInduction(self, content, ignore_c_step_section=True):
         "read and append airgapInduction section"
         import scipy.integrate as si
         import math
@@ -918,7 +921,9 @@ class Reader:
                 i1beta = True
                 continue
             if line.startswith("C_STEP"):
-                return   # ignore this section
+                if ignore_c_step_section:
+                    return  # ignore this section
+                continue
             try:
                 rec = self.__findNums(line)
                 if len(rec) == 10:
@@ -966,6 +971,10 @@ class Reader:
             self.airgapInduction['iq'] = iq
             self.airgapInduction['id'] = id
             nrows = len(self.airgapInduction['id'])
+        if not ignore_c_step_section:
+            # min 1 required (section with C_STEP)
+            nrows = max(1, nrows)
+            ncols = max(1, ncols)
 
         try:
             self.airgapInduction['an'] = [np.reshape(an[j][:nrows*ncols],
@@ -999,6 +1008,14 @@ class Reader:
                                                      [1:])
                     self.airgapInduction['Bm'] = zip(*zip(*self.airgapInduction['Bm'])
                                                      [1:])
+            elif not ignore_c_step_section:
+                # section with C_STEP and a single data linex
+                self.airgapInduction['an'] = [self.airgapInduction['an'][i][0:]
+                                              for i in range(4)]
+                self.airgapInduction['bn'] = [self.airgapInduction['bn'][i][0:]
+                                              for i in range(4)]
+                self.airgapInduction['Ba'] = self.airgapInduction['Ba'][0:]
+                self.airgapInduction['Bm'] = self.airgapInduction['Bm'][0:]
         except ValueError:
             print(self.airgapInduction['i1'])
 
@@ -1858,12 +1875,12 @@ class Reader:
         return self.__str__()
 
 
-def read(filename):
+def read(filename, **kwargs):
     """Read BCH/BATCH results from file *filename*."""
     import io
     bchresults = Reader()
     with io.open(filename, encoding='latin1', errors='ignore') as f:
-        bchresults.read(f.readlines())
+        bchresults.read(f.readlines(), **kwargs)
     return bchresults
 
 

femagtools/dxfsl/area.py

@@ -105,6 +105,12 @@ class Area(object):
     def elements(self):
         return self.area
 
+    def is_element_in_area(self, el):
+        for e in self.elements():
+            if el.has_same_nodes(e):
+                return True
+        return False
+
     def copy_of_elements(self):
         return [e.clone() for e in self.elements() if e]
 
@@ -1818,7 +1824,7 @@ class Area(object):
             logger.debug(">>> air is a circle")
             return self.type
 
-        self.set_close_to_start_end_angles(self, 0.0, alpha)
+        self.set_close_to_start_end_angles(0.0, alpha)
 
         if self.is_magnet_rectangle():
             self.type = TYPE_MAGNET_RECT  # magnet embedded
@@ -1863,6 +1869,11 @@ class Area(object):
         nodes = [n for n in self.virtual_nodes(parts=4)]
         return area_size(nodes)
 
+    def get_area_size(self):
+        if self.surface == 0.0:
+            self.surface = self.area_size()
+        return self.surface
+
     def set_surface(self, mirrored):
         self.surface = self.area_size()
         if self.close_to_endangle and mirrored:

femagtools/dxfsl/areabuilder.py

@@ -16,7 +16,7 @@ from femagtools.dxfsl.area import Area, TYPE_AIR
 from femagtools.dxfsl.functions import points_are_close, nodes_are_equal, distance
 from femagtools.dxfsl.functions import normalise_angle, positive_angle, point
 from femagtools.dxfsl.functions import alpha_line, alpha_points, alpha_angle
-from femagtools.dxfsl.functions import less, is_same_angle
+from femagtools.dxfsl.functions import less, less_equal, greater, is_same_angle
 from femagtools.dxfsl.functions import Timer
 from femagtools.dxfsl.journal import getJournal
 import io
@@ -135,7 +135,7 @@ class EdgeInfo(object):
         self.angle = positive_angle(alpha_angle(start_angle, self.n1_angle_ingoing()))
         logger.debug("set_direction_angle: angle is %s", self.angle)
 
-        if is_same_angle(0.0, self.angle, atol=0.008):  # 1/2 degree
+        if is_same_angle(0.0, self.angle, atol=0.015):  # 1/2 degree
             # reverse direction
             logger.debug("set_direction_angle: reverse direction( nearly 180 degrees)")
 
@@ -218,7 +218,7 @@ class EdgeInfo(object):
         myself_angle = self.angle
         other_angle = nbr_edge.angle
 
-        if is_same_angle(0.0, myself_angle):
+        if is_same_angle(0.0, myself_angle, atol=0.015):
             # 360 or 0 degrees => turn 180 degrees
             logger.debug("-- ATTENTION: myself %s turns nearly 180 degrees", self.classname())
             logger.debug("   the angle is %s", myself_angle)
@@ -261,7 +261,7 @@ class EdgeInfo(object):
                         logger.debug("#4: end of myself_direction_lefthand: ==> %s", left)
                         return left
 
-        if is_same_angle(0.0, other_angle, atol=0.008):  # 1/2 degree
+        if is_same_angle(0.0, other_angle, atol=0.015):  # 1/2 degree
             # 360 or 0 degrees => turn 180 degrees
             logger.debug("-- ATTENTION: other %s turns nearly 180 degrees", nbr_edge.classname())
             logger.debug("   the angle is %s", other_angle)
@@ -288,7 +288,7 @@ class EdgeInfo(object):
 
         logger.debug("-- angles: myself = %s,  other = %s",
                      myself_angle, other_angle)
-        if not is_same_angle(myself_angle, other_angle, atol=0.008):  # 1/2 degree
+        if not is_same_angle(myself_angle, other_angle, atol=0.015):  # 1/2 degree
             logger.debug("-- angles are different")
             left = myself_angle > other_angle
             log_lefthand(left, self, nbr_edge)
@@ -778,7 +778,7 @@ class AreaBuilder(object):
         assert(self.geom.area_list)
         return self.get_lower_border_line()
 
-    def close_outer_winding_areas(self):
+    def close_outer_winding_areas(self, color='red'):
         logger.debug("begin close_outer_winding_areas")
 
         airgap_line, airgap_el = self.get_outer_airgap_line()
@@ -787,6 +787,15 @@ class AreaBuilder(object):
         if len(airgap_line) < 5:
             return False
 
+        distlist = [distance(self.geom.center, n) for n in airgap_line]
+        min_dist = min(distlist)
+        max_dist = max(distlist)
+        geom_height = self.geom.max_radius - self.geom.min_radius
+        line_height = max_dist - min_dist
+        if line_height < geom_height * 0.2:
+            return 0
+
+        logger.debug("NODES: %s TO %s", airgap_line[0], airgap_line[-1])
         n1 = None
         dist_n1 = 0.0
 
@@ -795,22 +804,29 @@ class AreaBuilder(object):
         dist_prev = distance(self.geom.center, n_prev)
         alpha_prev = alpha_line(self.geom.center, n_prev)
         alpha_start = alpha_prev
-
         lines_created = 0
+        dist_ag = self.geom.min_radius
+        logger.debug("MIN RADIUS DIST: %s",dist_ag)
         for n in airgap_line[1:]:
             dist = distance(self.geom.center, n)
             alpha = alpha_line(self.geom.center, n)
+            logger.debug("Node %s, dist=%s, alpha=%s", n, dist, alpha)
             if not n1:
-                if dist > dist_prev and alpha < alpha_prev:
-                    n1 = n_prev
-                    dist_n1 = dist_prev
+                logger.debug("Previous, dist=%s, alpha=%s", dist_prev, alpha_prev)
+                if greater(dist_prev, dist_ag, rtol=1e-3, atol=1e-3):
+                    if greater(dist, dist_prev, rtol=1e-3, atol=1e-3) and \
+                       less(alpha, alpha_prev, rtol=1e-4, atol=1e-5):
+                        n1 = n_prev
+                        dist_n1 = dist_prev
+                        logger.debug("NODE1: %s  (%s)", n1, dist_n1)
             else:
-                if np.isclose(dist_n1, dist, rtol=1e-3, atol=1e-3):
+                if less_equal(dist, dist_n1, rtol=1e-3, atol=1e-2):
+                    logger.debug("NODE2: %s  (%s)", n, dist)
                     line = Line(Element(start=n1, end=n))
                     if e_prev.intersect_line(line):
                         logger.debug("___LINE NOT POSSIBLE___")
                     else:
-                        self.geom.add_line(n1, n, color='red')
+                        self.geom.add_line(n1, n, color=color)
                         lines_created += 1
                     n1 = None
                     dist_n1 = 0.0

femagtools/dxfsl/converter.py

@@ -229,7 +229,7 @@ def build_machine_rotor(machine, inner, mindist, plt, EESM=False, single=False):
         else:
             rebuild = machine_temp.create_mirror_lines_outside_magnets()
     if rebuild:
-        machine_temp.geom.create_list_of_areas(delete=True)
+        machine_temp.rebuild_subregions(EESM, single=single)
 
     if machine_temp.create_auxiliary_lines():
         logger.debug("Auxiliary Lines created: rebuild subregions")
@@ -286,6 +286,8 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
             machine_temp.create_mirror_lines_outside_windings()
     else:
         machine_temp = machine
+        if machine_temp.has_windings_in_the_middle():
+            machine_temp.create_mirror_lines_outside_windings()
 
     if machine_temp.geom.reduce_element_nodes(mindist):
         machine_temp.rebuild_subregions(EESM, single=single)
@@ -309,6 +311,9 @@ def build_machine_stator(machine, inner, mindist, plt, EESM=False, single=False)
                   plt, machine_temp.geom,
                   title="Stator Winding Slice after Rebuild")
 
+    if machine_temp.remove_tiny_air_areas():
+        machine_temp.rebuild_subregions(EESM, single=single)
+
     if machine_temp.create_auxiliary_lines():
         machine_temp.rebuild_subregions(EESM, single=single)
         plot_geom(False,  # for developer
@@ -1037,7 +1042,7 @@ def create_femag_parameters(m_inner, m_outer, nodedist=1):
     alfa_pole = geom_poles.get_alfa()
 
     params['tot_num_slot'] = num_slots
-    params['slot_area'] = slot_area
+    params['slot_area'] = float(slot_area)
     params['num_sl_gen'] = num_sl_gen
     params['num_poles'] = num_poles
     params['nodedist'] = nodedist

femagtools/dxfsl/fslrenderer.py

@@ -246,6 +246,37 @@ class FslRenderer(object):
                 'outer_da_end = {}'.format(
                     geom.dist_end_min_corner())
             ]
+        if inner:
+            r = np.linalg.norm(geom.start_corners[0])
+            if not np.isclose(geom.min_radius, r, rtol=1e-3):
+                slice = 1 if machine.is_mirrored() else 2
+                self.content += [
+                    '-- create air layer inside',
+                    'x0, y0 = {}, {}'.format(
+                        geom.start_min_corner(0),
+                        geom.start_min_corner(1)),
+                    'hair = 1.0',
+                    'parts = {}'.format(machine.get_num_parts()),
+                    'rmin = {}'.format(geom.min_radius),
+                    'r1 = rmin - hair',
+                    'r, phi = c2pr(x0, y0)',
+                    'x1, y1 = pr2c(r1, phi)',
+                    'x2, y2 = pr2c(r1, {}*math.pi/parts)'.format(slice),
+                    'x3, y3 = pr2c(r, {}*math.pi/parts)'.format(slice),
+                    'nc_line(x0, y0, x1, y1, 0)',
+                    'nc_circle_m(x1, y1, x2, y2, 0.0, 0.0, 0)',
+                    'nc_line(x2, y2, x3, y3, 0)',
+                    'x0, y0 = pr2c(rmin - hair/2, math.pi/parts/2)',
+                    'create_mesh_se(x0, y0)',
+                    '\n']
+            else:
+                self.content += [
+                    'parts = {}'.format(machine.get_num_parts()),
+                    'x0, y0 = {}, {}'.format(
+                        geom.start_min_corner(0),
+                        geom.start_min_corner(1)),
+                    'r1, phi = c2pr(x0, y0)']
+
         if self.mtype == 'PMSM':
             self.content += [
                          'xmag = {}',
@@ -256,6 +287,9 @@ class FslRenderer(object):
                          'if mcvkey_yoke == nil then',
                          '  mcvkey_yoke = "dummy"',
                          '  ur = 1000.0',
+                         ' else if mcvkey_teeth == nil then',
+                         ' mcvkey_teeth = mcvkey_yoke',
+                         'end',
                          'end',
                          'x0_iron_tooth, y0_iron_tooth = 0.0, 0.0',
                          'x0_iron_yoke, y0_iron_yoke = 0.0, 0.0',
@@ -324,7 +358,7 @@ class FslRenderer(object):
                         self.content.append(
                             'x0_shaft, y0_shaft = x0, y0')
 
-        self.content.append("create_mesh(x0, y0)\n")
+        self.content.append("create_mesh()\n")
 
         txt = ["if x0_iron_yoke > 0.0 then",
                "  if mcvkey_yoke ~= 'dummy' then",
@@ -387,22 +421,24 @@ class FslRenderer(object):
         # angle after mirroring
         self.content.append('alfa = {}\n'.format(geom.get_alfa()))
 
-        self.content += ['-- rotate',
-                         'x1, y1 = {}, {}'.format(
-                             geom.start_corners[0][0],
-                             geom.start_corners[0][1])]  # min xy1
         if outer:
-            self.content.append('x2, y2 = pr2c(r1, 0.0)')
+            self.content += ['-- rotate',
+                             'x1, y1 = {}, {}'.format(
+                                 geom.start_corners[0][0],
+                                 geom.start_corners[0][1]),  # min xy1
+                             'x2, y2 = pr2c(r1, 0.0)']
         else:
-            self.content.append('x2, y2 = {}, {}'.format(
-                geom.start_corners[1][0],
-                geom.start_corners[1][1]))  # max xy1
+            self.content += ['-- rotate',
+                             'x1, y1 = pr2c(r1, 0.0)',
+                             'x2, y2 = {}, {}'.format(
+                                 geom.start_corners[1][0],
+                                 geom.start_corners[1][1])]  # min xy1
 
         if geom.is_mirrored():
             self.content.append('x3, y3 = pr2c(x2, alfa)')
             self.content.append('x4, y4 = pr2c(x1, alfa)')
         elif outer:
-            self.content += ['x3, y3 = pr2c(r1, 2*math.pi/parts+phi)',
+            self.content += ['x3, y3 = pr2c(r1, 2*math.pi/parts)',
                              'x4, y4 = {}, {}'.format(
                                  geom.end_corners[0][0],
                                  geom.end_corners[0][1])]  # min xy4
@@ -410,10 +446,7 @@ class FslRenderer(object):
             self.content += ['x3, y3 = {}, {}'.format(
                                  geom.end_corners[-1][0],
                                  geom.end_corners[-1][1]), # min xy3
-                             'x4, y4 = {}, {}'.format(
-                                 geom.end_corners[0][0],
-                                 geom.end_corners[0][1]),  # min xy4
-                             'def_bcond_vpo(x4, y4, x1, y1)']
+                             'x4, y4 = pr2c(r1, 2*math.pi/parts)']
 
         self.content.append('if parts_gen > 1 then')
         if geom.corners_dont_match():

femagtools/dxfsl/geom.py

@@ -1182,7 +1182,7 @@ 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, delete=False):
+    def create_list_of_areas(self, main=False, delete=False, nolog=True):
         """ return list of areas for each node and their neighbors
         """
         if delete:  # clear list of areas
@@ -1193,7 +1193,7 @@ class Geometry(object):
             # list already available
             return
 
-        areabuilder = AreaBuilder(geom=self)
+        areabuilder = AreaBuilder(geom=self, nolog=nolog)
         areabuilder.create_list_of_areas(main=main)
         self.area_list = areabuilder.area_list
         logger.debug("area list created")
@@ -3337,6 +3337,31 @@ class Geometry(object):
         return [a for a in self.list_of_areas()
                 if a.is_type(type)]
 
+    def is_tooth(self, a, windings, wdg_min_dist, wdg_max_dist):
+        if a.around_windings(windings, self):
+            if a.close_to_ag:
+                return True
+            if self.is_inner:
+                if greater(a.min_dist, wdg_min_dist, atol=1e-1):
+                    return True
+            else:
+                if less(a.max_dist, wdg_max_dist, atol=1e-1):
+                    return True
+        return False
+
+    def between_airgap_and_winding(self, a,
+                                   wdg_min_angle,
+                                   wdg_max_angle,
+                                   wdg_min_dist,
+                                   wdg_max_dist):
+        if greater_equal(a.min_angle, wdg_min_angle) and \
+           less_equal(a.max_angle, wdg_max_angle):
+            if self.is_inner:
+                return less_equal(wdg_max_dist, a.min_dist)
+            else:
+                return less_equal(a.max_dist, wdg_min_dist)
+        return False
+
     def collect_windings(self):
         logger.debug("begin of collect_windings")
         good_windings = self.get_windings(AREA.TYPE_WINDINGS)
@@ -3409,7 +3434,7 @@ class Geometry(object):
             max_size, max_w = windings_surface[0]
             for sz, w in windings_surface[1:]:
                 logger.debug("winding size = %s", sz)
-                if sz / max_size < 0.70:
+                if sz / max_size < 0.60:
                     w.set_type(AREA.TYPE_AIR)
                     if sz / max_size < 0.2:
                         windings_found -= 1
@@ -3459,7 +3484,7 @@ class Geometry(object):
         air_areas = [a for a in self.list_of_areas()
                      if a.is_type(AREA.TYPE_AIR_OR_IRON)]
         for a in air_areas:
-            if a.around_windings(windings, self):
+            if a.around_windings(windings, self) and less(a.min_dist, wdg_max_dist - 0.5):
                 logger.debug("Area %s", a.identifier())
                 logger.debug(" - air-angle min/max = %s/%s",
                              a.min_air_angle,
@@ -3481,7 +3506,6 @@ class Geometry(object):
                            a.close_to_ag):
                             a.set_type(AREA.TYPE_AIR)  # air
                             continue
-
                         a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
                         continue
 
@@ -3510,14 +3534,28 @@ class Geometry(object):
                     a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
             else:
                 logger.debug("#5 not around windings")
-                a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
+                if self.between_airgap_and_winding(a,
+                                                   wdg_min_angle, wdg_max_angle,
+                                                   wdg_min_dist, wdg_max_dist):
+                    a.set_type(AREA.TYPE_AIR)  # air
+                else:
+                    if self.is_inner:
+                        if greater(a.min_dist, wdg_min_dist, atol=1e-1):
+                            a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
+                        else:
+                            a.set_type(AREA.TYPE_YOKE)  # iron shaft (Joch)
+                    else:
+                        if less(a.max_dist, wdg_max_dist, atol=1e-1):
+                            a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
+                        else:
+                            a.set_type(AREA.TYPE_YOKE)  # iron shaft (Joch)
 
         # yoke or shaft ?
         iron_areas = [a for a in self.list_of_areas()
                       if a.is_type(AREA.TYPE_YOKE)]
         for a in iron_areas:
             if a.around_windings(windings, self):
-                if less(a.min_dist, wdg_max_dist):
+                if less(a.min_dist, wdg_max_dist - 0.5):
                     if less_equal(a.max_dist, wdg_max_dist):
                         a.set_type(AREA.TYPE_TOOTH)  # iron shaft (Zahn)
                     else:
@@ -3922,6 +3960,15 @@ class Geometry(object):
             area.mark_airgap_corners(start_cp, end_cp)
         return
 
+    def get_areas_of_type(self, types=()):
+        return [area for area in self.list_of_areas()
+                if area.type in types]
+
+    def get_areas_of_irons(self):
+        return self.get_areas_of_type((AREA.TYPE_IRON,
+                                       AREA.TYPE_YOKE,
+                                       AREA.TYPE_TOOTH,))
+
     def num_areas_of_type(self, types=()):
         return len([area for area in self.list_of_areas()
                     if area.type in types])
@@ -4268,6 +4315,16 @@ class Geometry(object):
         for e in self.elements():
             e.adjust_points()
 
+    def split_with_point(self, p):
+        for e in self.elements(Shape):
+            elements = e.split([p])
+            if elements:
+                self.remove_edge(e)
+                for e in elements:
+                    self.add_element(e, rtol=self.rtol, atol=self.atol)
+                return True
+        return False
+
     def split_and_get_intersect_points(self, el, aktion=True, include_end=True):
         logger.debug("begin of split_and_get_intersect_points")
         rtol = 1e-03
@@ -4424,38 +4481,6 @@ class Geometry(object):
         builder = AreaBuilder(geom=self)
         return builder.create_inner_corner_auxiliary_areas(startangle, endangle)
 
-    def analyse_airgap_line(self, inner):
-        if inner:  # TODO
-            return False
-
-        areas = self.list_of_areas()
-        builder = AreaBuilder(geom=self)
-        ag_nodes, ag_el = builder.get_outer_airgap_line()
-        if not ag_nodes:
-            logger.warning("Fatal: No nodes found")
-            return False
-
-        distlist = [distance(self.center, n) for n in ag_nodes]
-        min_dist = min(distlist)
-        max_dist = max(distlist)
-        logger.debug("Airgap min/max from center: %s/%s", min_dist, max_dist)
-        for a in areas:
-            logger.debug("%s: min/max from center: %s/%s", a.identifier(), a.min_dist, a.max_dist)
-            logger.debug("%s: min/max x: %s/%s,  y:  %s/%s",
-                         a.identifier(),
-                         a.min_x, a.max_x,
-                         a.min_y, a.max_y)
-            if less_equal(a.min_x, -min_dist) and greater_equal(a.max_x, min_dist) and \
-               less_equal(a.min_y, -min_dist) and greater_equal(a.max_y, min_dist):
-                logger.debug("%s: around center", a.identifier())
-                continue
-            if np.isclose(a.min_dist, min_dist, rtol=1e-3, atol=1e-2):
-                continue
-            if less_equal(a.max_dist, max_dist, rtol=1e-3, atol=1e-2):
-                return False
-
-        return builder.close_outer_winding_areas()
-
     def adjust_outer_hull_for_symmetry(self):
         logger.debug("adjust_outer_hull_for_symmetry()")
         areas = self.list_of_areas()
@@ -4778,6 +4803,52 @@ class Geometry(object):
             return
         logger.warning("WARNING: airgap connecting nodes do not aline")
 
+    def remove_area(self, area):
+        logger.debug("Remove Area %s", area.identifier())
+        touching_areas = [(a.surface, a) for a in self.list_of_areas()
+                          if a.id != area.id and a.is_touching(area)]
+        if not touching_areas:
+            self.remove_edges(area.area)
+            return
+        touching_areas.sort(reverse=True)
+        sz, touching_a = touching_areas[0]
+        for e in area.area:
+            if touching_a.is_element_in_area(e):
+                self.remove_edge(e)
+
+    def remove_tiny_air_areas(self):
+        logger.debug("remove_tiny_air_areas()")
+        air_areas = [a for a in self.list_of_areas() if a.is_air()]
+        if not air_areas:
+            return False
+
+        def is_in_touch(air, area_list):
+            for a in area_list:
+                if air.is_touching(a):
+                    return True
+                if air.is_inside(a, self):
+                    return True
+            return False
+
+        areas = [a for a in self.list_of_areas() if a.is_winding() or a.is_magnet()]
+        if not areas:
+            return False
+
+        tiny_areas = [a for a in air_areas if not is_in_touch(a, areas)]
+        geom_surface = self.area_size()
+        angle_areas = [a for a in tiny_areas
+                      if (a.close_to_startangle or a.close_to_endangle)]
+        #inside_areas = [a for a in tiny_areas
+        #                if not (a.close_to_startangle or a.close_to_endangle) and \
+        #                   a.get_area_size() < geom_surface / 200]
+        tiny_areas = angle_areas
+        if not tiny_areas:
+            return False
+
+        for a in tiny_areas:
+            self.remove_area(a)
+        return True
+
     def print_nodes(self):
         print("=== List of Nodes ({}) ===".format(self.number_of_nodes()))
         for n in self.g.nodes():