femagtools 1.5.7__py3-none-any.whl → 1.6.0__py3-none-any.whl

femagtools/dxfsl/geom.py

@@ -16,7 +16,8 @@ import logging
 import sys
 from .corner import Corner
 from .area import Area
-from .shape import Element, Shape, Circle, Arc, Line, Point, is_Circle
+from .shape import Element, Shape, Circle, Arc, Line, Point
+from .shape import is_Circle, is_Arc, is_Line
 from .machine import Machine
 from .functions import less_equal, less, greater, greater_equal
 from .functions import distance, alpha_line, alpha_points, alpha_angle
@@ -112,10 +113,17 @@ def add_or_split(el, x, out_elements, rtol, atol):
             out_elements[x] = None
         split_el = el.split(points, rtol, atol)
         return split_el
-
     return []
 
 
+def add_element(geom, e, rtol, atol):
+    n = geom.find_nodes(e.start(), e.end())
+    try:
+        add_or_join(geom, n[0], n[1], e, rtol, atol)
+    except Exception as ex:
+        logger.warn("EXCEPTION in add_element: %s", ex)
+
+
 def add_or_join(geom, n1, n2, entity, rtol, atol):
     """ adds a new entity to graph or joins entity with existing
     geom: Geometry
@@ -125,7 +133,50 @@ def add_or_join(geom, n1, n2, entity, rtol, atol):
     if n1 == n2:
         logger.debug(
             "Tiny element with same node on both sides ignored: %s", n1)
+        logger.debug(
+            " -- element: %s", entity)
+
     else:
+        e = geom.get_edge_element(n1, n2)
+        if e:
+            logger.debug("Duplicate connection: %s <--> %s", n1, n2)
+            if is_Line(e):
+                if is_Line(entity):
+                    logger.debug("add_or_join(): Duplicate Lines ignored")
+                    return  # its ok
+
+            if is_Arc(e):
+                if is_Arc(entity):
+                    if points_are_close(e.center, entity.center, rtol=rtol, atol=atol):
+                        if points_are_close(e.p1, entity.p1):
+                            logger.debug("add_or_join(): Duplicate Arcs ignored")
+                            return  # its ok
+
+            if is_Circle(entity):
+                if is_Circle(e):
+                    logger.debug("add_or_join(): Duplicate Circle ignored")
+                    return  # its ok
+
+            if is_Circle(entity) or is_Circle(e):
+                e1, e2 = entity.cut_into_halves()
+                logger.debug("===== add_or_join(): Element near circle is cut into halves =====")
+                add_element(geom, e1, rtol, atol)
+                add_element(geom, e2, rtol, atol)
+                return  # halves installed
+
+            m1 = e.center_of_connection()
+            m2 = entity.center_of_connection()
+            logger.debug("midpoints: %s -- %s", m1, m2)
+            if points_are_close(m1, m2, rtol, 1e-2):
+                logger.debug("Elements are close together")
+                return  # ok
+
+            e1, e2 = entity.cut_into_halves()
+            logger.debug("===== add_or_join(): cut into halves =====")
+            add_element(geom, e1, rtol, atol)
+            add_element(geom, e2, rtol, atol)
+            return  # halves installed
+
         geom.add_edge(n1, n2, entity)
 
 
@@ -221,7 +272,7 @@ def polylines(entity, lf, rf, xoff=0.0, yoff=0.0, rotation=0.0):
         p1 = points[i]
         try:
             p2 = points[i+1]
-        except Exception as e:
+        except Exception:
             if not entity.is_closed:
                 break
             p2 = points[0]
@@ -276,6 +327,7 @@ def lw_polyline(entity, lf, xoff=0.0, yoff=0.0, rotation=0.0):
                    xoff=xoff, yoff=yoff,
                    rotation=rotation)
 
+
 def ellipse(entity, lf, xoff=0.0, yoff=0.0, rotation=0.0):
     w = np.linalg.norm(entity.major_axis) * 2
     h = entity.ratio * w
@@ -294,7 +346,7 @@ def ellipse(entity, lf, xoff=0.0, yoff=0.0, rotation=0.0):
     x, y = np.dot(R, [x, y])
     x += entity.center[0]
     y += entity.center[1]
-    points = np.array((x,y)).T
+    points = np.array((x, y)).T
     p1 = points[0]
     for p2 in points[1:]:
         yield Line(Element(start=p1, end=p2), lf,
@@ -488,7 +540,7 @@ def dxfshapes(dxffile, mindist=0.01, layers=[]):
     # dwg.header['$LUNITS']
     lf = 1
     if dwg.header.get('$LUNITS', 0) == 1:
-        #conv = [1, 2.54e-2, 10.12, 633.0, 1e-3, 1e-2, 1]
+        # conv = [1, 2.54e-2, 10.12, 633.0, 1e-3, 1e-2, 1]
         lf = 2.54e3
 
     rf = np.pi/180
@@ -919,11 +971,13 @@ class Geometry(object):
 
     def add_edge(self, n1, n2, entity):
         if points_are_close(n1, n2):
-            logger.debug("WARNING in add_edge(): Points ar close together")
-            logger.debug("        p1 = %s, p2 = %s", n1, n2)
+            logger.debug("WARNING in add_edge(): Points of %s are close together",
+                         entity.classname())
+            logger.debug("        n1 = %s, n2 = %s", n1, n2)
+            logger.debug("        p1 = %s, p2 = %s", entity.p1, entity.p2)
 
         entity.set_nodes(n1, n2)
-        logger.debug("add_edge %s - %s", n1, n2)
+        logger.debug("add_edge %s - %s  (%s)", n1, n2, entity.classname())
         self.g.add_edge(n1, n2, object=entity)
 
     def get_edge(self, eg):
@@ -984,7 +1038,6 @@ class Geometry(object):
                     self.rtol,
                     self.atol)
 
-
     def elements(self, type):
         """return lists of objects"""
         return [e[2]['object'] for e in self.g.edges(data=True)
@@ -1004,19 +1057,19 @@ class Geometry(object):
         rem_lines = []
         for p1, p2, data in [e for e in self.g.edges(data=True)
                              if isinstance(e[2]['object'], Line)]:
-            l = data['object']
-            if l.length() > length:
-                p = l.center_of_connection()
-                new_lines += l.split([p])
+            ln = data['object']
+            if ln.length() > length:
+                p = ln.center_of_connection()
+                new_lines += ln.split([p])
                 rem_lines.append((p1, p2))
 
         for p1, p2 in rem_lines:
             self._remove_edge(p1, p2)
-        for l in new_lines:
+        for new_ln in new_lines:
             add_or_join(self,
-                        l.node1(ndec),
-                        l.node2(ndec),
-                        l,
+                        new_ln.node1(ndec),
+                        new_ln.node2(ndec),
+                        new_ln,
                         self.rtol,
                         self.atol)
 
@@ -1157,7 +1210,7 @@ class Geometry(object):
         rtol = 1e-4
         atol = 1e-4
 
-        logger.debug("repair_hull_line(center=%s, angle=%s)", center, angle)
+        logger.debug("begin repair_hull_line(center=%s, angle=%s)", center, angle)
 
         if len(corners) < 2:
             # no hull without more than 1 corners
@@ -1182,6 +1235,7 @@ class Geometry(object):
                 # Both points are in the hull
                 el = data['object']
                 if isinstance(el, Line):
+                    logger.debug("remove Line: %s <> %s", p1, p2)
                     self._remove_edge(p1, p2)
                 else:
                     [corner.set_keep_node() for corner in clist_p1]
@@ -1217,6 +1271,8 @@ class Geometry(object):
 
         # Rebuild Corner-list after correction
         corners = self.get_corner_list(center, angle, rtol, atol)
+        for c in corners:
+            logger.debug("Correct Corner: %s", c)
 
         if with_center:
             c_corner = Corner(center, tuple(center))
@@ -1255,8 +1311,8 @@ class Geometry(object):
 
         corners = self.get_corner_list(self.center, angle)
         assert(corners)
-        c_min = Corner(center, point(self.center, self.min_radius, angle, ndec))
-        c_max = Corner(center, point(self.center, self.max_radius, angle, ndec))
+        c_min = Corner(self.center, point(self.center, self.min_radius, angle, ndec))
+        c_max = Corner(self.center, point(self.center, self.max_radius, angle, ndec))
 
         c_first = corners[0]
         if not c_min.is_same_corner(c_first):
@@ -1276,7 +1332,7 @@ class Geometry(object):
 
     def complete_hull_arc(self, startangle, startcorner,
                           endangle, endcorner, radius):
-        nodes = self.radius_nodes(center, radius, 1e-04, 1e-04)
+        nodes = self.radius_nodes(self.center, radius, 1e-04, 1e-04)
 
         if startcorner.is_new_point:
             start_p = startcorner.point()
@@ -1284,9 +1340,9 @@ class Geometry(object):
                             if not points_are_close(start_p, n)]
             nodes_sorted.sort()
             p = nodes_sorted[0][1]
-            angle_p = alpha_line(center, p)
+            angle_p = alpha_line(self.center, p)
             self.add_edge(start_p, p, Arc(
-                Element(center=center, radius=radius,
+                Element(center=self.center, radius=radius,
                         start_angle=startangle*180/np.pi,
                         end_angle=angle_p*180/np.pi)))
 
@@ -1296,9 +1352,9 @@ class Geometry(object):
                             if not points_are_close(end_p, n)]
             inx = len(nodes_sorted)-1
             p = nodes_sorted[inx][1]
-            angle_p = alpha_line(center, p)
+            angle_p = alpha_line(self.center, p)
             self.add_edge(p, end_p, Arc(
-                Element(center=center, radius=radius,
+                Element(center=self.center, radius=radius,
                         start_angle=angle_p*180/np.pi,
                         end_angle=endangle*180/np.pi)))
 
@@ -1693,7 +1749,7 @@ class Geometry(object):
     def the_point_is_inside(self, p, rtol=1e-04, atol=1e-04):
         for e in self.elements(Shape):
             if e.is_point_inside(p, rtol=rtol, atol=atol, include_end=True):
-                #logger.info("point %s is inside %s", p, e)
+                # logger.info("point %s is inside %s", p, e)
                 return True
         return False
 
@@ -1824,13 +1880,14 @@ class Geometry(object):
         alpha_start = alpha_line(e.center, e.p1)
         for x, p2 in sorted_points:
             alpha_end = alpha_line(e.center, p2)
-            pm = middle_point_of_arc(e.center, e.radius, p1, p2, rtol=rtol)
+            pm = middle_point_of_arc(e.center, e.radius, p1, p2, rtol=rtol, atol=atol)
             if is_point_inside_region(pm, center,
-                                      inner_circle.radius, outer_circle.radius,
-                                      start_angle, end_angle):
-
+                                      inner_circle.radius,
+                                      outer_circle.radius,
+                                      start_angle, end_angle,
+                                      rtol=rtol, atol=atol):
                 if not (len(points) > 1 and
-                        points_are_close(p1, p2, 1e-3, 1e-3)):
+                        points_are_close(p1, p2, rtol=rtol, atol=atol)):
                     if len(points) == 1 and e.rtheta is not None:
                         a = Arc(Element(center=e.center,
                                         radius=e.radius,
@@ -1846,7 +1903,6 @@ class Geometry(object):
                                         radius=e.radius,
                                         start_angle=alpha_start*180/np.pi,
                                         end_angle=alpha_end*180/np.pi))
-
                     new_elements.append(a)
             alpha_start = alpha_end
             p1 = p2
@@ -1862,7 +1918,6 @@ class Geometry(object):
             durch die Parameter definierten Teilkreisfläche befinden.
         """
         assert(isinstance(e, Circle))
-
         if is_same_angle(start_angle, end_angle):
             pts_inner = inner_circle.intersect_circle(e,
                                                       rtol,
@@ -1912,47 +1967,24 @@ class Geometry(object):
         sorted_points.sort()
 
         x, px = sorted_points[0]
-        del sorted_points[0]
+        sorted_points.append((x, px))
         p1 = px
         alpha_start = alpha_line(e.center, p1)
-        for x, p2 in sorted_points:
+        for x, p2 in sorted_points[1:]:
             alpha_end = alpha_line(e.center, p2)
-            pm = middle_point_of_arc(e.center, e.radius, p1, p2, rtol=rtol)
+            pm = middle_point_of_arc(e.center, e.radius, p1, p2, rtol=rtol, atol=atol)
             if is_point_inside_region(pm, center,
                                       inner_circle.radius,
                                       outer_circle.radius,
-                                      start_angle, end_angle):
-                alpha_middle = middle_angle(alpha_start, alpha_end)
-                arc1 = Arc(Element(center=e.center,
-                                   radius=e.radius,
-                                   start_angle=alpha_start*180/np.pi,
-                                   end_angle=alpha_middle*180/np.pi))
-                arc2 = Arc(Element(center=e.center,
-                                   radius=e.radius,
-                                   start_angle=alpha_middle*180/np.pi,
-                                   end_angle=alpha_end*180/np.pi))
-                new_elements.append(arc1)
-                new_elements.append(arc2)
-
+                                      start_angle, end_angle,
+                                      rtol=rtol, atol=atol):
+                a = Arc(Element(center=e.center,
+                                radius=e.radius,
+                                start_angle=alpha_start*180/np.pi,
+                                end_angle=alpha_end*180/np.pi))
+                new_elements.append(a)
             alpha_start = alpha_end
             p1 = p2
-
-        alpha_end = alpha_line(e.center, px)
-        pm = middle_point_of_arc(e.center, e.radius, p1, px, rtol=rtol)
-        if is_point_inside_region(pm, center,
-                                  inner_circle.radius, outer_circle.radius,
-                                  start_angle, end_angle):
-            alpha_middle = middle_angle(alpha_start, alpha_end)
-            arc1 = Arc(Element(center=e.center,
-                               radius=e.radius,
-                               start_angle=alpha_start*180/np.pi,
-                               end_angle=alpha_middle*180/np.pi))
-            arc2 = Arc(Element(center=e.center,
-                               radius=e.radius,
-                               start_angle=alpha_middle*180/np.pi,
-                               end_angle=alpha_end*180/np.pi))
-            new_elements.append(arc1)
-            new_elements.append(arc2)
         return new_elements
 
     def copy_shape(self,
@@ -1970,12 +2002,15 @@ class Geometry(object):
         """ Die Funktion kopiert die Teile von Shape-Objekten, welche sich in
             der durch die Parameter definierten Teilkreisfläche befinden.
         """
-        logger.debug('copy_shape(%s, %s)', startangle, endangle)
+        logger.debug('begin copy_shape(%s, %s)', startangle, endangle)
 
         if not rtol:
             rtol = self.rtol
         if not atol:
             atol = self.atol
+        rtol = 1e-5
+        atol = 1e-4
+        logger.debug(' -> rtol=%s,  atol=%s', rtol, atol)
 
         if is_same_angle(startangle, endangle):
             start_line = Line(
@@ -2028,7 +2063,6 @@ class Geometry(object):
                     atol=atol,
                     points_inner=pts_inner,
                     points_outer=pts_outer)
-
             elif isinstance(e, Circle):
                 new_elements += self.copy_circle(
                     self.center, radius, startangle, endangle,
@@ -2074,8 +2108,8 @@ class Geometry(object):
             logger.debug('new Geometry with split')
             geom = Geometry(new_elements,
                             center=center,
-                            rtol=0.05,
-                            atol=0.1,
+                            rtol=self.rtol,
+                            atol=self.atol,
                             is_inner=self.is_inner,
                             is_outer=self.is_outer,
                             split=split)
@@ -2090,7 +2124,7 @@ class Geometry(object):
         if delete_appendices:
             geom.delete_all_appendices()
             geom.set_center(self.center)
-
+        logger.debug('end copy_shape')
         return geom
 
     def copy_all_elements(self, alpha):
@@ -2450,7 +2484,7 @@ class Geometry(object):
         elif np.isclose(width*2, height, self.rtol, self.atol):
             radius = width
             logger.info("check for half machine")
-            set_center([mm[1], mm[3]-width])
+            self.set_center([mm[1], mm[3]-width])
             if self.check_hull(radius, mm[1], None, self.rtol, atol):
                 logger.info(" - it is a half")
                 return Machine(self, radius, np.pi/2.0, -np.pi/2.0)
@@ -2922,7 +2956,7 @@ class Geometry(object):
                 else:
                     logger.warning("   %s already removed ?!", id)
 
-        #for area in self.list_of_areas():
+        # for area in self.list_of_areas():
         #    logger.info("Inside %s is:", area.identifier())
         #    for id in area.areas_inside:
         #        logger.info(" ++ %s", id)
@@ -3189,27 +3223,29 @@ class Geometry(object):
                 if a.is_point_inside(p):
                     return a.id
             return 0
+
         #   -------------------------
         def connection_thru_main_area(pts):
             if len(pts) < 3:
-                return True  #ok
+                return True  # ok
             if len(areas_inside) < 2:
-                return True  #ok
+                return True  # ok
 
             id = id_of_inside_area(pts[0])
             if id == 0:  # strange
-                return False  #bad
+                return False  # bad
 
             next_id = id_of_inside_area(pts[1])
             if next_id == 0:
-                return True  #ok
+                return True  # ok
 
             id = next_id
             next_id = id_of_inside_area(pts[2])
             if id == next_id:  # thru inside-area
-                return True  #ok
+                return True  # ok
 
             return False
+
         #   ----------
         def takeSecond(elem):
             return elem[1]
@@ -3243,7 +3279,7 @@ class Geometry(object):
                           color=aux_color,
                           linestyle=aux_linestyle)
                 arc.set_attribute('iron_sep')
-                p = self.split_and_get_intersect_points(arc)
+                self.split_and_get_intersect_points(arc)
                 n = self.find_nodes(pts[0], pts[1])
                 self.add_edge(n[0], n[1], arc)
 
@@ -3745,7 +3781,7 @@ class Geometry(object):
                     try:
                         self._remove_edge(n0, n1)
                         self.add_edge(nn, n1, el)
-                    except Exception as e:
+                    except Exception:
                         logger.debug("delete of %s - %s failed", n0, n)
                         logger.debug("Element %s", el)
         return c

femagtools/dxfsl/machine.py

@@ -5,7 +5,7 @@
 from __future__ import print_function
 import numpy as np
 import logging
-from .shape import Element, Circle, Arc, Line, Shape
+from .shape import Element, Circle, Arc, Line
 from .corner import Corner
 from .functions import point, points_are_close, distance
 from .functions import alpha_angle, normalise_angle, middle_angle, third_angle
@@ -14,6 +14,7 @@ from .functions import within_interval, part_of_circle
 from .functions import less, less_equal, greater, greater_equal
 logger = logging.getLogger('femagtools.geom')
 
+
 #############################
 #          Machine          #
 #############################
@@ -231,6 +232,7 @@ class Machine(object):
         return clone.get_machine()
 
     def copy_mirror(self, startangle, midangle, endangle):
+        logger.debug("begin of copy_mirror")
         geom1 = self.geom.copy_shape(self.radius,
                                      startangle,
                                      midangle,
@@ -254,6 +256,7 @@ class Machine(object):
         machine.mirror_geom = geom2
         machine.mirror_startangle = midangle
         machine.mirror_endangle = endangle
+        logger.debug("end of copy_mirror")
         return machine
 
     def has_mirrored_windings(self):
@@ -279,16 +282,16 @@ class Machine(object):
             self.endangle += angle
 
     def airgap(self, correct_airgap=0.0, correct_airgap2=0.0, atol=0.1):
-        logger.debug('locking for airgap')
+        logger.debug('begin airgap (locking for airgap)')
         self.airgap_radius = 0.0
         self.airgap2_radius = 0.0
 
         if np.isclose(self.radius, 0.0):
-            logger.debug('no radius')
+            logger.debug('end airgap: no radius')
             return False
 
         if correct_airgap < 0:
-            logger.debug('no airgap')
+            logger.debug('end airgap: no airgap (%s)', correct_airgap)
             return False  # no airgap
 
         self.airgaps = []
@@ -354,33 +357,39 @@ class Machine(object):
             logger.error("No airgap with radius {} found"
                          .format(correct_airgap))
             self.show_airgap_candidates(airgap_candidates, False)
+            logger.debug("end airgap: bad")
             return True  # bad exit
 
         if correct_airgap2 > 0.0 and self.airgap2_radius == 0.0:
             logger.error("No airgap2 with radius {} found"
                          .format(correct_airgap2))
             self.show_airgap_candidates(airgap_candidates, False)
+            logger.debug("end airgap: bad")
             return True  # bad exit
 
         if len(self.airgaps) == 0:
-            logger.debug('No airgap found')
+            logger.debug('end airgap: No airgap found')
             return False  # no airgaps found
 
         if self.airgap_radius > 0.0:
+            logger.debug("end airgap: radius=%s", self.airgap_radius)
             return False  # correct airgap set
 
         gaps = [c for b, c, d in airgap_candidates if b == 0]
 
         if len(gaps) == 1:  # one candidate without border intersection
             self.airgap_radius = gaps[0].radius
+            logger.debug("end airgap: radius=%s", self.airgap_radius)
             return False  # ok
 
         if len(airgap_candidates) == 1:  # one candidate found
             self.airgap_radius = airgap_candidates[0][1].radius
+            logger.debug("end airgap: radius=%s", self.airgap_radius)
             return False  # ok
 
         self.airgap_radius = self.show_airgap_candidates(airgap_candidates,
                                                          True)
+        logger.debug("end airgap: radius=%s", self.airgap_radius)
         return False  # ok
 
     def show_airgap_candidates(self, airgap_candidates, get_one):
@@ -451,7 +460,7 @@ class Machine(object):
                 self.geom.delete_circle((0.0, 0.0), first_dist)
 
     def repair_hull(self):
-        logger.debug('repair_hull')
+        logger.debug('begin repair_hull(%s, %s)', self.startangle, self.endangle)
         if self.is_full() and not self.has_airgap():
             self.delete_center_circle()
 
@@ -468,7 +477,7 @@ class Machine(object):
         logger.debug('end of repair_hull')
 
     def repair_hull_geom(self, geom, startangle, endangle):
-        logger.debug('repair_hull_geom')
+        logger.debug('begin repair_hull_geom (%s, %s)', startangle, endangle)
 
         c_corner = Corner(self.center, self.center)
         start_corners = geom.get_corner_list(self.center, startangle)

femagtools/dxfsl/plotrenderer.py

@@ -287,7 +287,7 @@ class PlotRenderer(object):
 
         self.ax.axis('scaled')
         self.ax.set_aspect('equal')
-        
+
         self.ax.set_xlim(x_min, x_max)
         self.ax.set_ylim(y_min, y_max)
 
@@ -360,7 +360,7 @@ class PlotRenderer(object):
         area.render(self, 'red', with_nodes=True)
 
         self.ax.axis('scaled')
-        self.ax.set_aspect('equal')       
+        self.ax.set_aspect('equal')
         pl.show()
 
     def draw_slot(self, id, slot, ax):