femagtools 1.6.8__py3-none-any.whl → 1.7.1__py3-none-any.whl

femagtools/dxfsl/area.py

@@ -15,8 +15,8 @@ from .functions import less_equal, less, greater_equal, greater
 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
-from .functions import area_size
-from .shape import Element, Shape, Line, Arc, Circle, is_Circle
+from .functions import area_size, normalise_angle, positive_angle
+from .shape import Element, Shape, Line, Arc, Circle, is_Circle, is_Line, is_Arc
 
 logger = logging.getLogger('femagtools.area')
 
@@ -27,11 +27,26 @@ logger = logging.getLogger('femagtools.area')
 
 area_number = 0
 
+TYPE_AIR = 0
+TYPE_IRON = 1
+TYPE_WINDINGS = 2
+TYPE_MAGNET_AIRGAP = 3
+TYPE_MAGNET_RECT = 4
+TYPE_YOKE = 5
+TYPE_TOOTH = 6
+TYPE_MAGNET_OR_AIR = 8
+TYPE_AIR_OR_IRON = 9
+TYPE_MAGNET_OR_IRON = 9
+TYPE_SHAFT = 10
+TYPE_MAGNET_RECT_NEAR_AIRGAP = 11
+TYPE_WINDINGS_OR_AIR = 12
+TYPE_MAGNET_UNDEFINED = 99
+TYPE_GROUP = 20
 
 class Area(object):
     def __init__(self, area, center, sym_tolerance):
         self.area = area
-        self.type = 0  # material
+        self.type = -1  # material
         self.phi = 0.0
         self.min_angle = 0.0
         self.max_angle = 0.0
@@ -43,9 +58,13 @@ class Area(object):
         self.close_to_startangle = False
         self.close_to_endangle = False
         self.mag_rectangle = False
+        self.mag_width = 0.0
         self.min_dist = 99999.0
         self.max_dist = 0.0
-        self.minmax_xy = [0,0,0,0]
+        self.min_x = None
+        self.max_x = None
+        self.min_y = None
+        self.max_y = None
         self.height = 0.0
         self.alpha = 0.0
         self.count = 1
@@ -62,7 +81,9 @@ class Area(object):
         global area_number
         area_number += 1
         self.id = area_number
+        self.is_child = False
         self.areas_inside = {}
+        self.areas_of_group = []
 
     def identifier(self):
         return "{}-{}".format(self.id, self.type)
@@ -180,88 +201,94 @@ class Area(object):
             last_point = next_nodes[-1]
 
     def legend(self):
-        if self.type == 1:
+        if self.type == TYPE_IRON:
             return 'Iron'
-        if self.type == 2:
+        if self.type == TYPE_WINDINGS:
             return 'Windings'
-        if self.type == 3 or self.type == 4:
+        if self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT:
             return 'Magnet'
-        if self.type == 5:
+        if self.type == TYPE_YOKE:
             return 'Yoke'
-        if self.type == 6:
+        if self.type == TYPE_TOOTH:
             return 'Tooth'
-        if self.type == 10:
+        if self.type == TYPE_SHAFT:
             return 'Shaft'
         return ''
 
     def name(self):
-        if self.type == 1:
+        if self.type == TYPE_IRON:
             return 'Iron'
-        if self.type == 2:
+        if self.type == TYPE_WINDINGS:
             return 'Wndg'
-        if self.type == 3 or self.type == 4:
+        if self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT:
             return 'Mag'
-        if self.type == 5:
+        if self.type == TYPE_YOKE:
             return 'StJo'
-        if self.type == 6:
+        if self.type == TYPE_TOOTH:
             return 'StZa'
-        if self.type == 10:
+        if self.type == TYPE_SHAFT:
             return 'Shft'
         return ''
 
     def color(self):
-        if self.type == 1:
+        if self.type == TYPE_IRON:
             return 'cyan'
-        if self.type == 2:
+        if self.type == TYPE_WINDINGS:
             return 'green'
-        if self.type == 3 or self.type == 4:
+        if self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT:
             return 'red'
-        if self.type == 5:
+        if self.type == TYPE_YOKE:
             return 'cyan'
-        if self.type == 6:
+        if self.type == TYPE_TOOTH:
             return 'skyblue'
-        if self.type == 10:
+        if self.type == TYPE_SHAFT:
             return 'lightgrey'
         return 'white'
 
     def color_alpha(self):
-        if self.type == 1:
+        if self.type == TYPE_IRON:
             return 0.3
-        if self.type == 2:
+        if self.type == TYPE_WINDINGS:
             return 1.0
-        if self.type == 3 or self.type == 4:
+        if self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT:
             return 1.0
-        if self.type == 5:
+        if self.type == TYPE_YOKE:
             return 0.5
-        if self.type == 6:
+        if self.type == TYPE_TOOTH:
             return 1.0
-        if self.type == 10:
+        if self.type == TYPE_SHAFT:
             return 0.8
         return 1.0
 
     def is_iron(self):
-        return self.type == 1 or self.type == 5 or self.type == 6
+        return \
+            self.type == TYPE_IRON or \
+            self.type == TYPE_YOKE or \
+            self.type == TYPE_TOOTH
 
     def is_stator_iron_yoke(self):
-        return self.type == 5
+        return self.type == TYPE_YOKE
 
     def is_stator_iron_tooth(self):
-        return self.type == 6
+        return self.type == TYPE_TOOTH
 
     def is_rotor_iron(self):
-        return self.type == 1
+        return self.type == TYPE_IRON
 
     def is_winding(self):
-        return self.type == 2
+        return self.type == TYPE_WINDINGS
 
     def is_magnet(self):
-        return self.type == 3 or self.type == 4
+        return self.type == TYPE_MAGNET_AIRGAP or self.type == TYPE_MAGNET_RECT
 
     def is_shaft(self):
-        return self.type == 10
+        return self.type == TYPE_SHAFT
 
     def is_air(self):
-        return self.type == 0
+        return self.type == TYPE_AIR
+
+    def is_type(self, type):
+        return self.type == type
 
     def set_type(self, t):
         self.type = t
@@ -270,7 +297,7 @@ class Area(object):
         if not self.area:
             return
 
-        self.minmax_xy = self.minmax()
+        self.min_x, self.max_x, self.min_y, self.max_y = self.minmax()
         s = self.area[0]
         mm_angle = s.minmax_angle_from_center(center)
         self.min_angle = mm_angle[0]
@@ -289,8 +316,10 @@ class Area(object):
         self.alpha = round(alpha_angle(self.min_angle, self.max_angle), 3)
 
     def center_is_inside(self, center):
-        if self.minmax_xy[0] < center[0] and self.minmax_xy[1] > center[0] and \
-           self.minmax_xy[2] < center[1] and self.minmax_xy[3] > center[1]:
+        if less(self.min_x, center[0], rtol=1e-03, atol=1e-04) and \
+           greater(self.max_x, center[0], rtol=1e-03, atol=1e-04) and \
+           less(self.min_y, center[1], rtol=1e-03, atol=1e-04) and \
+           greater(self.max_y, center[1], rtol=1e-03, atol=1e-04):
             return True
         return False
 
@@ -329,9 +358,8 @@ class Area(object):
             return False
 
         line = Line(Element(start=p1, end=p2))
-        plist = self.intersect_points(line)
+        plist = self.get_intersect_points(line)
         points = len(plist)
-        plist.sort()
 
         aux_lines = [e for e in self.area if e.has_attribute('auxline')]
         if aux_lines:
@@ -358,6 +386,15 @@ class Area(object):
     def is_touching_both_sides(self):
         return (self.close_to_startangle and self.close_to_endangle)
 
+    def is_in_touch_with_area(self, geom, a):
+        n1 = self.area[0].n1
+        n2 = a.area[0].n2
+        try:
+            return nx.has_path(geom.g, n1, n2)
+        except nx.NetworkXError:
+            logger.warning("has_path() failed")
+            return False
+
     def has_connection(self, geom, a, ndec):
         assert(self.area)
         assert(a.area)
@@ -395,12 +432,14 @@ class Area(object):
                 d = distance(p1, p2)
                 gap_list.append((d, (p1, p2), dist_id, a.get_id()))
 
-        d, p1, p2 = a.get_nearest_point(center, radius, rightangle)
-        if p1:
-            gap_list.append((d, (p1, p2), dist_id, a.get_id()))
-        d, p1, p2 = a.get_nearest_point(center, radius, leftangle)
-        if p1:
-            gap_list.append((d, (p1, p2), dist_id, a.get_id()))
+        if rightangle is not None:
+            d, p1, p2 = a.get_nearest_point(center, radius, rightangle)
+            if p1:
+                gap_list.append((d, (p1, p2), dist_id, a.get_id()))
+        if leftangle is not None:
+            d, p1, p2 = a.get_nearest_point(center, radius, leftangle)
+            if p1:
+                gap_list.append((d, (p1, p2), dist_id, a.get_id()))
         if not gap_list:
             return []
         gap_list.sort()
@@ -635,11 +674,21 @@ class Area(object):
                 return True
         return False
 
-    def intersect_points(self, line):
+    def get_intersect_points(self, line, rtol=1.e-4, atol=1e-3):
         points = []
         for e in self.area:
-            points += e.intersect_line(line, include_end=True)
-        return points
+            points += e.intersect_line(line, rtol=rtol, atol=atol, include_end=True)
+        if not points:
+            return []
+        points = [(x, y) for x, y in points]
+        points.sort()
+        p1 = points[0]
+        pts = [p1]
+        for p2 in points[1:]:
+            if not points_are_close(p1, p2, rtol=rtol, atol=atol):
+                pts.append(p2)
+            p1 = p2
+        return pts
 
     def is_point_inside(self, pt):
         for e in self.area:
@@ -647,14 +696,49 @@ class Area(object):
                 return True
         return False
 
+    def the_area_is_inside_area(self, a):
+        p = a.area[0].n1
+        return self.the_point_is_inside_area(p)
+
+    def the_point_is_inside_area(self, p):
+        x, y = p
+        if less_equal(x, self.min_x) or greater_equal(x, self.max_x):
+            return False
+        if less_equal(y, self.min_y) or greater_equal(y, self.max_y):
+            return False
+
+        p1 = (self.min_x - 5, y)
+        p2 = (self.max_x + 5, y)
+        line = Line(Element(start=p1, end=p2))
+        pts = self.get_intersect_points(line)
+        if len(pts) % 2 != 0:
+            return False
+
+        c = 0
+        for ax, ay in pts:
+            if not less(ax, x):
+                if c % 2 != 1:
+                    return False
+                break
+            c += 1
+
+        if not c < len(pts):
+            return False
+
+        ax, ay = pts[c]
+        if not less(x, ax):
+            return False
+        return True
+
     def get_best_point_inside(self, geom):
-        mm = self.minmax_xy
-        px1 = mm[0]-5
-        px2 = mm[1]+5
+        px1 = self.min_x - 5
+        px2 = self.max_x + 5
 
-        y_dist = mm[3] - mm[2]
+        y_dist = self.max_y - self.min_y
         step = y_dist / 6
-        y_list = np.arange(mm[2] + step*0.3, mm[3] - step*0.3, step)
+        y_list = np.arange(self.min_y + step * 0.3,
+                           self.max_y - step * 0.3,
+                           step)
 
         lines = []
         for y in y_list:
@@ -745,10 +829,9 @@ class Area(object):
 
     def get_point_inside(self, geom):
         """return point inside area"""
-        mm = self.minmax_xy
-        y = (mm[2]+mm[3])/2
-        p1 = (mm[0]-5, y)
-        p2 = (mm[1]+5, y)
+        y = (self.min_y + self.max_y) / 2
+        p1 = (self.min_x - 5, y)
+        p2 = (self.max_x + 5, y)
         line = Line(Element(start=p1, end=p2))
 
         points = []
@@ -820,6 +903,32 @@ class Area(object):
             renderer.fill(x, y, color, alpha)
         return True
 
+    def magnet_arrow_length(self):
+        if self.is_type(TYPE_MAGNET_AIRGAP):
+            return (self.max_dist - self.min_dist) * 0.9
+        if self.is_type(TYPE_MAGNET_RECT):
+            return self.mag_width
+        return 0.0
+
+    def render_magnet_phi(self, renderer, length):
+        if not self.is_magnet():
+            return
+        p1 = None
+        p2 = None
+        if self.is_type(TYPE_MAGNET_AIRGAP):
+            mid = middle_angle(self.min_angle, self.max_angle)
+            d = self.min_dist + (self.max_dist - self.min_dist) * 0.3
+            p1 = point((0.0, 0.0), d, mid)
+        if self.is_type(TYPE_MAGNET_RECT):
+            x = self.min_x + (self.max_x - self.min_x) / 2
+            y = self.min_y + (self.max_y - self.min_y) / 2
+            p1 = (x, y)
+        if p1 is None:
+            return
+        p2 = point(p1, length, self.phi)
+        renderer.arrow(p1, p2, linewidth=1.2)
+        return
+
     def render_legend(self, renderer):
         return renderer.new_legend_handle(self.color(),
                                           self.color_alpha(),
@@ -867,25 +976,16 @@ class Area(object):
                 return False
         return True
 
-    def has_round_edges(self):
-        arcs = 0
-        for e in self.area:
-            # if isinstance(e, Line):
-            #    if not np.isclose(angle, alpha_line(center, e.p1)):
-            #        return False
-            #    if not np.isclose(angle, alpha_line(center, e.p2)):
-            #        return False
-            if isinstance(e, Arc):
-                arcs += 1
-
-        return arcs > 0
-
     def is_shaft_area(self, center):
         logger.debug("Begin of check shaft")
 
-        if not self.is_touching_both_sides():
-            logger.debug("End of check shaft: don't touch both sides")
-            return False
+        #if not self.is_touching_both_sides():
+        #    logger.debug("End of check shaft: don't touch both sides")
+        #    return False
+
+        if np.isclose(0.0, self.min_dist, rtol=1e-6, atol=1e-4):
+            logger.debug("End of check shaft: ok (node in center)")
+            return True
 
         for n in self.list_of_nodes():
             a = alpha_line(center, n)
@@ -900,247 +1000,143 @@ class Area(object):
                 continue
             logger.debug("End of check shaft: no")
             return False
+
         logger.debug("End of check shaft: ok")
         return True
 
-    def is_rectangle(self):
-        lines = [[c, e.m(99999.0), e.length()]
-                 for c, e in enumerate(self.area)
-                 if isinstance(e, Line)]
-        lines.sort()
-
-        line_count = 1
-        m_first = 0.0
-        m_prev = 999.999999
-        c_prev = -99
-        m_all = []
-        for c, m, l in lines:
-            if c_prev >= 0:
-                if np.isclose(m_prev, m, atol=0.001):
-                    if c_prev+1 != c:
-                        # Gleiche Steigung, aber keine Verlängerung
-                        line_count += 1
-                        m_all.append(m_prev)
-                else:
-                    line_count += 1
-                    m_all.append(m_prev)
-            else:
-                m_first = m
+    def get_magnet_line_angles(self):
+        lines = [e for e in self.area if is_Line(e)]
+        if len(lines) < 4:
+            logger.debug("get_magnet_line_angles: only %s lines", len(lines))
+            return []
 
-            m_prev = m
-            c_prev = c
+        angles = []
+        prev_angle = lines[0].get_positive_angle()
+        logger.debug("first angle = %s", prev_angle)
+        prev_length = lines[0].length()
 
-        m_all.append(m_prev)
+        for line in lines[1:]:
+            this_angle = line.get_positive_angle()
+            logger.debug("next angle = %s", this_angle)
+            this_length = line.length()
 
-        if np.isclose(m_prev, m_first, atol=0.001):
-            line_count -= 1
+            if np.isclose(prev_angle, this_angle, rtol=1e-04, atol=1e-02):
+                # same direction
+                prev_length += this_length
+            else:
+                angles.append((prev_length, prev_angle))
+                prev_angle = this_angle
+                prev_length = this_length
 
-        if line_count == 4:
-            logger.debug("is_rectangle: m={}".format(m_all))
-            if not np.isclose(m_all[0], m_all[2], atol=0.001):
-                return False
-            if not np.isclose(m_all[1], m_all[3], atol=0.001):
-                return False
-            return True
+        if not angles:
+            logger.debug("get_magnet_line_angles: only one angle")
+            return []
 
-        return False
+        this_length, this_angle = angles[0]
+        if not np.isclose(prev_angle, this_angle, rtol=1e-04, atol=1e-02):
+            angles.append((prev_length, prev_angle))
+        else:
+            prev_length += this_length
+            angles[0] = (prev_length, prev_angle)
 
-    def is_mag_rectangle(self):
-        lines_ceml = [[c, e, e.m(99999.0), e.length()]
-                      for c, e in enumerate(self.area)]
-        # c = Count
-        # e = Element
-        # m = Steigung
-        # l = Länge
-        # L = class Line
-        if len(lines_ceml) < 4:
-            return False
+        l, first_angle = angles[0]
+        l, last_angle = angles[-1]
+        if np.isclose(first_angle, last_angle, rtol=1e-04, atol=1e-02):
+            del angles[-1]
+        return angles
 
-        logger.debug("=== BEGIN OF is_mag_rectangle() [{} lines]"
-                     .format(len(lines_ceml)))
-
-        c_prev = lines_ceml[0][0]
-        a_prev = 999
-        p = None
-
-        e0 = lines_ceml[0][1]
-        e0_p1 = e0.p1
-        e0_p2 = e0.p2
-        L_prev = isinstance(e0, Line)
-        l_prev = lines_ceml[0][3]
-        m_prev = lines_ceml[0][2]
-
-        e1 = lines_ceml[1][1]
-        e1_p1 = e1.p1
-        e1_p2 = e1.p2
-
-        if (points_are_close(e0_p2, e1_p1, atol=1e-02) or
-                points_are_close(e0_p2, e1_p2, atol=1e-02)):
-            a_prev = alpha_line(e0_p1, e0_p2)
-            p = e0_p2
-        elif (points_are_close(e0_p1, e1_p1, atol=1e-02) or
-              points_are_close(e0_p1, e1_p2, atol=1e-02)):
-            a_prev = alpha_line(e0_p2, e0_p1)
-            p = e0_p1
-        else:
-            logger.error(
-                "ERROR: is_mag_rectangle(): points are not close together")
-            logger.error("       e0 p1={}, p2={}".format(e0_p1, e0_p2))
-            logger.error("       e1 p1={}, p2={}".format(e1_p1, e1_p2))
-            return False
+    def get_magnet_phi(self, angles):
+        if not angles:
+            return 0.0
 
-        def alpha_current(p, e):
-            if points_are_close(p, e.p1, atol=1e-02):
-                return e.p2, alpha_line(e.p1, e.p2), isinstance(e, Line)
-            if points_are_close(p, e.p2, atol=1e-02):
-                return e.p1, alpha_line(e.p2, e.p1), isinstance(e, Line)
-            logger.error(
-                "ERROR: is_mag_rectangle(): points are not close together")
-            logger.error("       p={}, p1={}, p2={}".format(p, e.p1, e.p2))
-            return None, None, False
-
-        lines_clamL = []
-        for c, e, m, l in lines_ceml[1:]:
-            p, a_curr, L_curr = alpha_current(p, e)
-            if not p:
-                return False
+        angles.sort(reverse=True)
+        # calculate orientation (no rectangle check)
+        l, alpha = angles[0]
+        phi = normalise_angle(alpha + np.pi/2)
+        logger.debug("alpha = %s, phi = %s", alpha, phi)
 
-            if is_same_angle(a_prev, a_curr, atol=0.01):
-                # its the same angle and both are Lines
-                # assert(np.isclose(m_prev, m, atol=0.001))
-                if c_prev+1 != c:
-                    logger.debug(" - ok, but not an extension")
-                    # ..., but not an extension
-                    lines_clamL.append([c_prev, l_prev, a_prev, m])
-                    l_prev = e.length()
-                else:
-                    # ... and an extension
-                    l_prev += e.length()
-                    logger.debug(" - ok, it's an extension")
-            else:
-                # it's a different angle
-                logger.debug(" - diff, angle {} and {} not equal "
-                             .format(a_prev, a_curr))
-                lines_clamL.append([c_prev, l_prev, a_prev, m_prev, L_prev])
-                l_prev = e.length()
-
-            a_prev = a_curr
-            L_prev = L_curr
-            m_prev = m
-            c_prev = c
-
-        lines_clamL.append([c_prev, l_prev, a_prev, m_prev, L_prev])
-        if np.isclose(lines_clamL[0][2], lines_clamL[-1][2], atol=0.001):
-            # Gleicher Winkel am Anfang und am Ende
-            lines_clamL[0][1] += lines_clamL[-1][1]  # length
-            del lines_clamL[-1]
-            logger.debug(" > last entry deleted")
-
-        if len(lines_clamL) < 4:
-            logger.debug("=== END OF is_mag_rectangle(): NO RECTANGLE #1")
-            return False
+        mid = middle_angle(self.min_angle, self.max_angle)
+        angle = alpha_angle(mid, phi)
+        logger.debug("phi=%s, mid=%s, angle=%s", phi, mid, angle)
 
-        lines_lmcL = [[l, m, c, L] for c, l, a, m, L in lines_clamL]
-        lines_lmcL.sort(reverse=True)
-
-        if not np.isclose(lines_lmcL[0][1], lines_lmcL[1][1], atol=0.05):
-            # Die Steigungen der zwei längsten Linien müssen gleich sein
-            logger.debug("--- m %s <> %s ---",
-                         lines_lmcL[0][1],
-                         lines_lmcL[1][1])
-            logger.debug("--- l %s, %s, %s ---",
-                         lines_lmcL[0][0],
-                         lines_lmcL[1][0],
-                         lines_lmcL[2][0])
-            logger.debug("=== END OF is_mag_rectangle(): NO RECTANGLE #2")
-            return False
+        if greater(angle, np.pi * 0.5, rtol=1e-5) and \
+           less(angle, np.pi * 1.5, rtol=1e-5):
+            phi = normalise_angle(phi + np.pi)
 
-        def excursion_to_same_direction(clam):
-            if len(clam) < 4:
-                return False
+        logger.debug("phi of magnet %s is %s", self.identifier(), phi)
+        return phi
 
-            alpha = alpha_angle(clam[0][2], clam[1][2])
-            clockwise = not alpha < np.pi
+    def get_magnet_orientation(self):
+        logger.debug("get magnet orientation for %s", self.identifier())
+        if self.is_type(TYPE_MAGNET_RECT):
+            angles = self.get_magnet_line_angles()
+            return self.get_magnet_phi(angles)
 
-            angle_prev = clam[1][2]
-            for c, l, angle_curr, m, t in clam[2:]:
-                alpha = alpha_angle(angle_prev, angle_curr)
-                if clockwise:
-                    if alpha < np.pi:
-                        return False
+        if self.is_type(TYPE_MAGNET_AIRGAP):
+            if self.close_to_endangle:
+                if self.close_to_startangle:
+                    return middle_angle(self.min_angle, self.max_angle)
                 else:
-                    if alpha > np.pi:
-                        return False
-                angle_prev = angle_curr
-            return True  # end of all_lines_with_same_direction()
+                    return self.max_angle
+            return middle_angle(self.min_angle, self.max_angle)
 
-        lines_cmL = [[c, m, L] for l, m, c, L in lines_lmcL[0:4]]
-        lines_cmL.sort()
+        return 0.0
 
-        if np.isclose(lines_cmL[0][1], lines_cmL[2][1], atol=0.001):
-            if not (lines_cmL[0][2] and lines_cmL[2][2]):
-                logger.debug("=== END OF is_mag_rectangle(): not 2 lines #1")
-                return False
-            ok = excursion_to_same_direction(lines_clamL)
-            logger.debug("=== END OF is_mag_rectangle(): OK = {} #1"
-                         .format(ok))
-            return ok
-        if np.isclose(lines_cmL[1][1], lines_cmL[3][1], atol=0.001):
-            if not (lines_cmL[1][2] and lines_cmL[3][2]):
-                logger.debug("=== END OF is_mag_rectangle(): not 2 lines #2")
-                return False
+    def is_magnet_rectangle(self):
+        angles = self.get_magnet_line_angles()
 
-            ok = excursion_to_same_direction(lines_clamL)
-            logger.debug("=== END OF is_mag_rectangle(): OK = {} #2"
-                         .format(ok))
-            return ok
+        if len(angles) != 4:
+            logger.debug("is_magnet_rectangle: %s angles, not 4", len(angles))
+            return False
 
-        logger.debug("=== END OF is_mag_rectangle(): NO RECTANGLE #3")
-        return False
+        for l, a in angles:
+            logger.debug("+ magnet_rectangle: alpha=%s,  length=%s", a, l)
 
-    def get_mag_orient_rectangle(self):
-        lines = [[e.m(99999.0), e.length(), alpha_line(e.p1, e.p2)]
-                 for e in self.area
-                 if isinstance(e, Line)]
-        lines.sort()
-
-        m_prev = 999.999999
-        a_prev = 0.0
-        l_total = 0.0
-        line_length = []
-        for m, l, a in lines:
-            if np.isclose(m_prev, m):
-                l_total += l
-            else:
-                if l_total > 0.0:
-                    line_length.append((l_total, m_prev, a_prev))
-                l_total = l
-                m_prev = m
-                a_prev = a
-
-        if l_total > 0.0:
-            line_length.append((l_total, m_prev, a_prev))
-        line_length.sort(reverse=True)
-
-        alpha = line_length[0][2]
-        if alpha < 0.0:
-            alpha += np.pi
-        alpha = alpha + np.pi/2
-        if alpha > np.pi:
-            alpha = alpha - np.pi
-        return alpha
-
-    def get_mag_orientation(self):
-        if self.mag_rectangle:
-            return self.get_mag_orient_rectangle()
+        length_0, angle_0 = angles[0]
+        length_1, angle_1 = angles[1]
+        length_2, angle_2 = angles[2]
+        length_3, angle_3 = angles[3]
 
-        if self.close_to_endangle:
-            if self.close_to_startangle:
-                return middle_angle(self.min_angle, self.max_angle)
-            else:
-                return self.max_angle
+        if not np.isclose(angle_0, angle_2, rtol=1e-03, atol=0.05):
+            logger.debug("is_magnet_rectangle: angles %s and %s not equal",
+                         angle_0, angle_2)
+            return False
+
+        if not np.isclose(angle_1, angle_3, rtol=1e-03, atol=0.05):
+            logger.debug("is_magnet_rectangle: angles %s and %s not equal",
+                         angle_1, angle_3)
+            return False
+
+        if angle_0 > angle_1:
+            a0 = angle_0
+            a1 = angle_1 + np.pi/2
         else:
-            return middle_angle(self.min_angle, self.max_angle)
+            a0 = angle_1
+            a1 = angle_0 + np.pi/2
+        if not np.isclose(a0, a1, rtol=1e-03, atol=0.05):
+            logger.debug("is_magnet_rectangle: not a rectange (%s neq %s)", a0, a1)
+            return False
+
+        turn_left = False
+        turn_right = False
+        for n1, n2, e in self.list_of_elements():
+            if is_Arc(e):
+                if e.get_node_number(n1) == 1:
+                    turn_left = True
+                else:
+                    turn_right = True
+
+        if turn_left and turn_right:
+            logger.debug("is_magnet_rectangle: arcs with different directions")
+            return False
+
+        self.phi = self.get_magnet_phi(angles)
+        angles.sort()
+        l, alpha = angles[0]
+        self.mag_width = l
+        logger.debug("Area %s is a rectangle with phi %s",
+                     self.identifier(), self.phi)
+        return True
 
     def around_windings(self, areas, geom):
         for a in areas:
@@ -1164,6 +1160,10 @@ class Area(object):
                 return True
         return False
 
+    def is_close_to_border(self, angle, border_angle):
+        return np.isclose(angle, border_angle,
+                          rtol=1e-03, atol=1e-03)
+
     def mark_stator_subregions(self,
                                is_inner,
                                stator_size,
@@ -1175,7 +1175,7 @@ class Area(object):
         alpha = round(alpha, 6)
 
         if self.is_circle():
-            self.type = 0  # air
+            self.type = TYPE_AIR  # air
             return self.type
 
         ag_delta = (r_out - r_in) / 500.0
@@ -1216,24 +1216,24 @@ class Area(object):
 
         if self.has_iron_separator():
             logger.debug("***** iron (has iron separator)\n")
-            self.type = 1  # iron
+            self.type = TYPE_IRON  # iron
             return self.type
 
         if is_inner:
             # looking for shaft
             if close_to_opposition and not self.close_to_ag:
                 if self.is_shaft_area(center):
-                    self.type = 10  # shaft
+                    self.type = TYPE_SHAFT  # shaft
                     logger.debug("***** shaft (close to opposition)\n")
                     return self.type
 
         if close_to_opposition:
-            self.type = 5  # iron yoke (Joch)
+            self.type = TYPE_YOKE  # iron yoke (Joch)
             logger.debug("***** iron yoke #1\n")
             return self.type
 
         if self.close_to_startangle and self.close_to_endangle:
-            self.type = 5  # iron yoke (Joch)
+            self.type = TYPE_YOKE  # iron yoke (Joch)
             logger.debug("***** iron yoke #2\n")
             return self.type
 
@@ -1250,21 +1250,21 @@ class Area(object):
 
             if self.alpha / air_alpha > 2:
                 logger.debug("***** windings near airgap\n")
-                self.type = 2  # windings
+                self.type = TYPE_WINDINGS  # windings
             else:
-                self.type = 9  # air or iron near windings and near airgap?
+                self.type = TYPE_AIR_OR_IRON  # air or iron near windings and near airgap?
                 logger.debug("***** air or iron ??\n")
             return self.type
 
         if self.close_to_startangle:
             if self.is_half_circle(center, self.min_angle):
-                self.type = 0  # air
+                self.type = TYPE_AIR  # air
                 logger.debug("***** air (part of a circle)\n")
                 return self.type
 
         if self.close_to_endangle:
             if self.is_half_circle(center, self.max_angle):
-                self.type = 0  # air
+                self.type = TYPE_AIR  # air
                 logger.debug("***** air (part of a circle)\n")
                 return self.type
 
@@ -1282,32 +1282,32 @@ class Area(object):
         if self.min_angle > 0.001:
             if self.max_angle < alpha - 0.001:
                 if bad_winding_position():
-                    self.type = 12  # windings or air
+                    self.type = TYPE_WINDINGS_OR_AIR  # windings or air
                     logger.debug("***** windings or air #1\n")
                 else:
-                    self.type = 2  # windings
+                    self.type = TYPE_WINDINGS  # windings
                     logger.debug("***** windings #1\n")
                 return self.type
             if mirrored:
                 if bad_winding_position():
-                    self.type = 12  # windings or air
+                    self.type = TYPE_WINDINGS_OR_AIR  # windings or air
                     logger.debug("***** windings or air #2\n")
                 else:
-                    self.type = 2  # windings
+                    self.type = TYPE_WINDINGS  # windings
                     logger.debug("***** windings #2\n")
                 return self.type
 
-            self.type = 0  # air
+            self.type = TYPE_AIR  # air
             logger.debug("***** air #3")
 
         if self.close_to_startangle or self.close_to_endangle:
             f = self.surface / stator_size
             if f < 0.02:  # area_size less then 2 percent of stator size
                 # Luftloch
-                self.type = 0  # air
+                self.type = TYPE_AIR  # air
                 logger.debug("***** small area => air\n")
             else:
-                self.type = 9  # air or iron near windings and near airgap?
+                self.type = TYPE_AIR_OR_IRON  # air or iron near windings and near airgap?
                 logger.debug("***** air or iron close to border\n")
             return self.type
 
@@ -1315,32 +1315,34 @@ class Area(object):
         return 0
 
     def mark_rotor_subregions(self, is_inner, mirrored, alpha,
-                              center, r_in, r_out):
+                              center, r_in, r_out,
+                              startangle,
+                              endangle):
         logger.debug("mark_rotor_subregions")
 
         alpha = round(alpha, 6)
 
         if self.is_circle():
-            self.type = 0  # air
+            self.type = TYPE_AIR  # air
             logger.debug(">>> air is a circle")
             return self.type
 
         if is_inner:
-            self.close_to_ag = np.isclose(r_out, self.max_dist, atol=0.005)
+            self.close_to_ag = np.isclose(r_out, self.max_dist, rtol=1e-9, atol=0.005)
             close_to_opposition = greater_equal(r_in * 1.05, self.min_dist)
             airgap_radius = r_out
             opposite_radius = r_in
             airgap_toleranz = -(self.max_dist - self.min_dist) / 50.0  # 2%
         else:
-            self.close_to_ag = np.isclose(r_in, self.min_dist, atol=0.005)
+            self.close_to_ag = np.isclose(r_in, self.min_dist, rtol=1e-9, atol=0.005)
             close_to_opposition = greater_equal(self.max_dist * 1.05, r_out)
             airgap_radius = r_in
             opposite_radius = r_out
             airgap_toleranz = (self.max_dist - self.min_dist) / 50.0  # 2%
 
-        self.close_to_startangle = np.isclose(self.min_angle, 0.0,
+        self.close_to_startangle = np.isclose(self.min_angle, startangle,
                                               1e-04, 1e-04)
-        self.close_to_endangle = np.isclose(self.max_angle, alpha,
+        self.close_to_endangle = np.isclose(self.max_angle, endangle,
                                             1e-04, 1e-04)
 
         logger.debug("\n***** mark_rotor_subregions [{}] *****"
@@ -1359,28 +1361,29 @@ class Area(object):
 
         if self.has_iron_separator():
             logger.debug("***** iron (has iron separator)\n")
-            self.type = 1  # iron
+            self.type = TYPE_IRON  # iron
             return self.type
 
         if is_inner:
             # looking for shaft
             if close_to_opposition and not self.close_to_ag:
+                logger.debug("-- check for shaft")
                 if self.is_shaft_area(center):
-                    self.type = 10  # shaft
+                    self.type = TYPE_SHAFT  # shaft
                     logger.debug("***** shaft (close to opposition)\n")
                     return self.type
 
         if close_to_opposition:
-            self.type = 1  # iron
+            self.type = TYPE_IRON  # iron
             logger.debug("***** iron (close to opposition)\n")
             return self.type
 
         if self.close_to_startangle and self.close_to_endangle:
-            self.type = 1  # iron
+            self.type = TYPE_IRON  # iron
             logger.debug("***** iron (close to both sides)\n")
             return self.type
 
-        self.mag_rectangle = self.is_mag_rectangle()
+        self.mag_rectangle = self.is_magnet_rectangle()
 
         if self.close_to_ag:
             mm = self.minmax_angle_dist_from_center(center,
@@ -1389,47 +1392,50 @@ class Area(object):
             air_alpha = round(alpha_angle(mm[0], mm[1]), 3)
             logger.debug(" - air_alpha          : {}".format(air_alpha))
 
+            if self.mag_rectangle:
+                self.type = TYPE_MAGNET_RECT_NEAR_AIRGAP  # magnet near airgap
+                logger.debug("***** magnet (airgap, embedded, phi={})\n".
+                             format(self.phi))
+                return self.type
+
             if air_alpha / alpha < 0.2:
-                self.phi = self.get_mag_orientation()
-                self.type = 8  # air or magnet ?
+                self.type = TYPE_MAGNET_OR_AIR  # air or magnet ?
                 logger.debug("***** air #1 (close to airgap)\n")
                 return self.type
 
             if air_alpha / alpha > 0.6:
-                self.phi = self.get_mag_orientation()
-                self.type = 3  # magnet
+                self.type = TYPE_MAGNET_AIRGAP  # magnet (no rectangle)
                 logger.debug("***** magnet (close to airgap)\n")
             else:
-                self.phi = self.get_mag_orientation()
-                self.type = 9  # iron or magnet ?
+                self.type = TYPE_MAGNET_OR_IRON  # iron or magnet ?
                 logger.debug("***** iron or magnet(close to airgap)\n")
             return self.type
 
         if self.mag_rectangle:
-            self.phi = self.get_mag_orientation()
-            self.type = 4  # magnet embedded
+            # phi is already calculated and set
+            self.type = TYPE_MAGNET_RECT  # magnet embedded
             logger.debug("***** magnet (embedded, phi={})\n".format(
                 self.phi))
             return self.type
 
         if not (self.close_to_startangle or self.close_to_endangle):
-            self.type = 0  # air
+            self.type = TYPE_AIR  # air
             logger.debug("***** air (somewhere)\n")
             return self.type
 
         if self.close_to_startangle:
             if self.is_half_circle(center, self.min_angle):
-                self.type = 0  # air
+                self.type = TYPE_AIR  # air
                 logger.debug("***** air (part of a circle)\n")
                 return self.type
 
         if self.close_to_endangle:
             if self.is_half_circle(center, self.max_angle):
-                self.type = 0  # air
+                self.type = TYPE_AIR  # air
                 logger.debug("***** air (part of a circle)\n")
                 return self.type
 
-        self.type = 0  # air
+        self.type = TYPE_AIR  # air
         logger.debug("***** air (remains)\n")
         return self.type
 
@@ -1438,33 +1444,32 @@ class Area(object):
         logger.debug("mark_unknown_subregions")
 
         if self.is_circle():
-            self.type = 0  # air
+            self.type = TYPE_AIR  # air
             logger.debug(">>> air is a circle")
             return self.type
 
         self.close_to_startangle = np.isclose(self.min_angle, 0.0)
         self.close_to_endangle = np.isclose(self.max_angle, alpha)
 
-        if self.is_mag_rectangle():
-            self.type = 4  # magnet embedded
+        if self.is_magnet_rectangle():
+            self.type = TYPE_MAGNET_RECT  # magnet embedded
             logger.debug(">>> magnet embedded")
-            self.phi = self.get_mag_orient_rectangle()
             return self.type
 
         close_to_max_radius = np.isclose(r_out, self.max_dist)
         close_to_min_radius = np.isclose(r_in, self.min_dist)
 
         if close_to_max_radius and close_to_min_radius:
-            self.type = 1  # iron
+            self.type = TYPE_IRON  # iron
             logger.debug(">>> iron close to min- and max-radius")
             return self.type
 
         if self.close_to_startangle and self.close_to_endangle:
-            self.type = 1  # iron
+            self.type = TYPE_IRON  # iron
             logger.debug(">>> iron close to start- and end-angle")
             return self.type
 
-        self.type = 0  # air
+        self.type = TYPE_AIR  # air
         logger.debug(">>> air remains")
         return self.type
 
@@ -1551,74 +1556,6 @@ class Area(object):
             for i in a.nested_areas_inside():
                 yield i
 
-    def crunch_area(self, geom):
-        n1_prev = None
-        e_prev = None
-        logger.debug("crunch area %s", self.identifier())
-
-        if self.is_circle():
-            return 0
-
-        c = 0
-        for n1, n2, e in self.list_of_elements():
-            if e_prev is not None:
-                if len([nbr for nbr in geom.g.neighbors(n1)]) == 2:
-                    e_new = e_prev.concatenate(n1_prev, n2, e)
-                    if e_new is not None:
-                        e_prev_dict = geom.g.get_edge_data(n1_prev, n1)
-                        e_dict = geom.g.get_edge_data(n1, n2)
-
-                        logger.debug("--> remove from %s to %s [%s, %s, %s]",
-                                     n1_prev,
-                                     n1,
-                                     e_prev_dict[0],
-                                     e_prev_dict[1],
-                                     e_prev_dict[2])
-                        logger.debug("    remove %s", e_prev)
-                        geom.remove_edge(e_prev)
-
-                        logger.debug("--> remove from %s to %s [%s, %s, %s]",
-                                     n1,
-                                     n2,
-                                     e_dict[0],
-                                     e_dict[1],
-                                     e_dict[2])
-                        logger.debug("    remove %s", e)
-                        if e.get_node_number(n1) == 1:
-                            flag1 = e_dict[1]
-                            flag2 = e_dict[2]
-                        else:
-                            flag1 = e_dict[2]
-                            flag2 = e_dict[1]
-                        geom.remove_edge(e)
-
-                        logger.debug("--> add from %s to %s",
-                                     n1_prev,
-                                     n2)
-                        logger.debug("    add %s", e_new)
-                        geom.add_edge(n1_prev, n2, e_new)
-
-                        e_new_dict = geom.g.get_edge_data(n1_prev, n2)
-                        e_new_dict[0] = True
-                        if e_new.get_node_number(n1_prev) == 1:
-                            e_new_dict[1] = flag1
-                            e_new_dict[2] = flag2
-                        else:
-                            e_new_dict[1] = flag2
-                            e_new_dict[2] = flag1
-
-                        logger.debug("    new dict: [%s, %s, %s]",
-                                     e_new_dict[0],
-                                     e_new_dict[1],
-                                     e_new_dict[2])
-                        e_prev = e_new
-                        c += 1
-                        continue
-
-            n1_prev = n1
-            e_prev = e
-        return c
-
     def __str__(self):
         return "Area {}\n".format(self.id) + \
             "distance...............: from {} to {}\n".\