femagtools 1.7.9__py3-none-any.whl → 1.8.1__py3-none-any.whl

femagtools/dxfsl/geom.py

@@ -811,6 +811,10 @@ class Geometry(object):
     def get_neighbors(self, n):
         return [nbr for nbr in self.g.neighbors(n)]
 
+    def num_of_neighbors(self, n):
+        nbrs = [nbr for nbr in self.g.neighbors(n)]
+        return len(nbrs)
+
     def angle_nodes(self, center, angle, rtol, atol):
         if np.isclose(abs(angle), np.pi, rtol, atol):
             angle_func = positive_angle
@@ -868,8 +872,8 @@ class Geometry(object):
         logger.debug("begin of dist_end_max_corner")
         logger.debug("end corners: %s", self.end_corners)
 
-        #if self.is_mirrored():
-        #    return self.dist_start_max_corner()
+        if self.is_mirrored():
+            return self.dist_start_max_corner()
         d = distance(self.center, self.end_corners[-1])
         logger.debug("end of dist_end_max_corner: %s", d)
         return d
@@ -1845,14 +1849,22 @@ class Geometry(object):
         return []
 
     def reduce_winding_nodes(self, mindist=0.01):
+        return self.reduce_element_nodes(mindist=mindist,
+                                         area_types=(AREA.TYPE_WINDINGS,))
+
+    def reduce_element_nodes(self, mindist=0.01, area_types=()):
+        timer = Timer(start_it=True)
+        nodes_deleted = 0
         for area in self.list_of_areas():
-            if area.is_winding():
-                reduced_shapes = area.reduce_nodes(mindist)
-                if reduced_shapes:
-                    area.remove_edges(self.g, ndec)
-                    area.area = reduced_shapes
-                    for r in reduced_shapes:
-                        self.add_element(r, rtol=self.rtol, atol=self.atol)
+            if not area_types or area.type in area_types:
+                nodes_deleted += area.reduce_element_nodes(self, mindist)
+
+        t = timer.stop("-- {} nodes deleted in %0.4f seconds --".format(nodes_deleted))
+        self.journal.put('time_deleting_nodes', t)
+        if nodes_deleted:
+            self.journal.put('nodes_deleted', nodes_deleted)
+            self.area_list = []
+        return nodes_deleted > 0
 
     def render_areagroups(self, renderer):
         if not self.areagroup_list:
@@ -2741,7 +2753,7 @@ class Geometry(object):
             intersection = False
             inner_gap_list = []
             for no_a in my_notouch:
-                if no_a.intersect_line(line):
+                if no_a.intersect_area(line):
                     intersection = True
                     logger.debug("   --> intersection with %s",
                                  no_a.get_id())
@@ -2805,6 +2817,7 @@ class Geometry(object):
                 pts = self.split_and_get_intersect_points(line)
                 if len(pts) != 2:
                     logger.error("ERROR in create_aux_lines()")
+                    self.journal.put("warning", "Error while creating auxiliary lines")
                     logger.debug("Points: %s", pts)
                     logger.debug("Line: %s", line)
 
@@ -3598,6 +3611,16 @@ class Geometry(object):
                 return True
         return False
 
+    def windings_in_the_middle(self, midangle):
+        wdg_areas = [a for a in self.list_of_areas()
+                     if a.is_winding()]
+        logger.info("%s windings in geom", len(wdg_areas))
+        for a in wdg_areas:
+            if greater(a.max_angle, midangle) and \
+               less(a.min_angle, midangle):
+                return True
+        return False
+
     def looking_for_corners(self):
         if self.is_inner:
             logger.debug("looking_for_corners: inner")
@@ -3613,16 +3636,21 @@ class Geometry(object):
             area.mark_airgap_corners(start_cp, end_cp)
         return
 
-    def num_areas_of_type(self, type):
+    def num_areas_of_type(self, types=()):
         return len([area for area in self.list_of_areas()
-                    if area.is_type(type)])
+                    if area.type in types])
 
     def area_size_of_type(self, type):
         return sum([area.surface for area in self.list_of_areas()
                     if area.is_type(type)])*1e-3
 
     def num_of_windings(self):
-        return self.num_areas_of_type(AREA.TYPE_WINDINGS)
+        return self.num_areas_of_type((AREA.TYPE_WINDINGS,))
+
+    def num_of_irons(self):
+        return self.num_areas_of_type((AREA.TYPE_IRON,
+                                       AREA.TYPE_YOKE,
+                                       AREA.TYPE_TOOTH,))
 
     def area_close_to_endangle(self, type):
         return len([area for area in self.list_of_areas()
@@ -4184,9 +4212,9 @@ class Geometry(object):
         if not ok1:  # fatal => ignore
             logger.debug("end repair_border_line: missing point %s", n1)
             return False
-        d1, n1, ok1 = nodes[-1]
-        if not ok1:  # fatal => ignore
-            logger.debug("end repair_border_line: missing point %s", n1)
+        d2, n2, ok2 = nodes[-1]
+        if not ok2:  # fatal => ignore
+            logger.debug("end repair_border_line: missing point %s", n2)
             return False
 
         remove_n1 = None
@@ -4218,89 +4246,132 @@ class Geometry(object):
         logger.debug("end repair_border_line")
         return True
 
-    def create_boundery_nodes(self,
+    def create_boundary_nodes(self,
                               center,
                               startangle,
                               endangle,
                               rtol=None, atol=None):
+        logger.debug("begin of create_boundary_nodes")
         if not rtol:
-            rtol = 1e-4
+            rtol = 1e-3
         if not atol:
             atol = 1e-3
 
-        start_nodes = [n for n in self.angle_nodes(center, startangle, rtol, atol)]
-        end_nodes = [n for n in self.angle_nodes(center, endangle, rtol, atol)]
-        alpha = alpha_angle(startangle, endangle)
-
-        logger.debug("begin of create_boundery_nodes")
-        start_rot_nodes = self.rotate_nodes(alpha, start_nodes)
-        end_rot_nodes = self.rotate_nodes(-alpha, end_nodes)
-
-        def miss_nodelist(src_nodelist, dest_nodelist):
-            nlist = []
-            for src_n in src_nodelist:
-                ok = False
-                for dest_n in dest_nodelist:
-                    if points_are_close(src_n, dest_n, rtol=rtol, atol=atol):
-                        ok = True
-                        break
-                if not ok:
-                    nlist.append(src_n)
-            return nlist
-
-        logger.debug("Begin with Nodes Start=%s,  End=%s", len(start_nodes), len(end_nodes))
-
-        missing_end_nodes = miss_nodelist(start_rot_nodes, end_nodes)
-        missing_start_nodes = miss_nodelist(end_rot_nodes, start_nodes)
-
-        if missing_start_nodes:
-            logger.debug("%s missing start nodes", len(missing_start_nodes))
-            start_nodes = [(distance(center, n), n, True) for n in start_nodes]
-            for n in missing_start_nodes:
-                start_nodes.append((distance(center, n), n, False))
-            start_nodes.sort()
-            if not self.repair_border_line(start_nodes):
-                logger.debug("end of create_boundery_nodes (failed)")
-                return
-        else:
-            start_nodes = [(distance(center, n), n, True) for n in start_nodes]
-            start_nodes.sort()
-
-        if missing_end_nodes:
-            logger.debug("%s missing end nodes", len(missing_end_nodes))
-            end_nodes = [(distance(center, n), n, True) for n in end_nodes]
-            for n in missing_end_nodes:
-                end_nodes.append((distance(center, n), n, False))
-            end_nodes.sort()
-            if not self.repair_border_line(end_nodes):
-                logger.debug("end of create_boundery_nodes (failed)")
-                return
-        else:
-            end_nodes = [(distance(center, n), n, True) for n in end_nodes]
-            end_nodes.sort()
+        def check_line(nlist):
+            d, n1, b = nlist[0]
+            for d, n2, b in nlist[1:]:
+                if not self.get_edge_element(n1, n2):
+                    return False
+                n1 = n2
+            return True
 
-        start_nodes = [(distance(center, n), n)
+        start_nodes = [(distance(center, n), n, True)
                        for n in self.angle_nodes(center, startangle, rtol, atol)]
         start_nodes.sort()
-        end_nodes = [(distance(center, n), n)
+        d_start1, n, b = start_nodes[0]
+        if not points_are_close(self.start_corners[0], n):
+            logger.warning("end of create_boundary_nodes: corner missing in start boundary")
+            return False
+        d_start2, n, b = start_nodes[-1]
+        if not points_are_close(self.start_corners[-1], n):
+            logger.warning("end of create_boundary_nodes: corner missing in start boundary")
+            return False
+        if not check_line(start_nodes):
+            logger.warning("end of create_boundary_nodes: bad start boundary")
+            return False
+
+        logger.debug("Start Nodes")
+        [logger.debug(" --> %s", x) for x in start_nodes]
+
+        end_nodes = [(distance(center, n), n, True)
                      for n in self.angle_nodes(center, endangle, rtol, atol)]
         end_nodes.sort()
+        d_end1, n, b = end_nodes[0]
+        if not points_are_close(self.end_corners[0], n):
+            logger.warning("end of create_boundary_nodes: corner missing in end boundary")
+            return False
+        d_end2, n, b = end_nodes[-1]
+        if not points_are_close(self.end_corners[-1], n):
+            logger.warning("end of create_boundary_nodes: corner missing in end boundary")
+            return False
+        if not check_line(end_nodes):
+            logger.warning("end of create_boundary_nodes: bad end boundary")
+            return False
 
-        logger.debug("End with Nodes Start=%s,  End=%s", len(start_nodes), len(end_nodes))
+        logger.debug("End Nodes")
+        [logger.debug(" --> %s", x) for x in end_nodes]
 
-        nodes = [n for d, n in start_nodes]
-        start_rot_nodes = self.rotate_nodes(alpha, nodes)
+        logger.debug("Lower Corners: %s <> %s", d_start1, d_end1)
+        if not np.isclose(d_start1, d_end1, rtol=self.rtol, atol=self.atol):
+            logger.warning("end of create_boundary_nodes: corners dont match")
+            return False
 
-        for d, node in start_nodes:
-            self.set_point_of_node(node, node)
-        i = 0
-        if len(end_nodes) == len(start_rot_nodes):
-            for d, node in end_nodes:
-                self.set_point_of_node(node, start_rot_nodes[i])
-                i += 1
+        logger.debug("Upper Corners: %s <> %s", d_start2, d_end2)
+        if not np.isclose(d_start2, d_end2, rtol=self.rtol, atol=self.atol):
+            logger.warning("end of create_boundary_nodes: corners dont match")
+            return False
 
-        logger.debug("end of create_boundery_nodes")
-        return
+        if len(start_nodes) == 2 and len(end_nodes) == 2:
+            logger.debug("end of create_boundary_nodes: only corners available")
+            return False  # ok
+
+        def node_distance_list(nodelist1, nodelist2):
+            distlist = []
+            i1 = 0
+            i2 = 0
+            while i1 < len(nodelist1) and i2 < len(nodelist2):
+                d1, n1, b1 = nodelist1[i1]
+                d2, n2, b2 = nodelist2[i2]
+                if np.isclose(d1, d2, rtol=self.rtol, atol=self.atol):
+                    distlist.append((d1, True, True))
+                    i1 += 1
+                    i2 += 1
+                elif d1 > d2:
+                    distlist.append((d2, False, True))
+                    i2 += 1
+                else:
+                    distlist.append((d1, True, False))
+                    i1 += 1
+            if not i1 == len(nodelist1) and i2 == len(nodelist2):
+                return []
+            return distlist
+
+        distance_list = node_distance_list(start_nodes, end_nodes)
+        [logger.debug("distance: %s, (%s, %s)", d, b1, b2)
+         for d, b1, b2 in distance_list]
+
+        diff = len(distance_list) - len(start_nodes)
+        done = False
+        if not diff == 0:
+            logger.debug("%s missing start nodes", diff)
+            done = True
+            for d, in_start, in_end in distance_list:
+                if not in_start:
+                    p = point(self.center, d, startangle)
+                    start_nodes.append((d, p, False))
+            start_nodes.sort()
+            assert(len(start_nodes) == len(distance_list))
+            if not self.repair_border_line(start_nodes):
+                logger.debug("end of create_boundary_nodes (failed)")
+                return False
+
+        diff = len(distance_list) - len(end_nodes)
+        if not diff == 0:
+            logger.debug("%s missing end nodes", diff)
+            done = True
+            for d, in_start, in_end in distance_list:
+                if not in_end:
+                    p = point(self.center, d, endangle)
+                    end_nodes.append((d, p, False))
+            end_nodes.sort()
+            assert(len(end_nodes) == len(distance_list))
+
+            if not self.repair_border_line(end_nodes):
+                logger.debug("end of create_boundary_nodes (failed)")
+                return False
+
+        logger.debug("end of create_boundary_nodes")
+        return done
 
     def set_point_of_node(self, node, p):
         if isinstance(node, list):

femagtools/dxfsl/journal.py

@@ -121,8 +121,8 @@ class Journal(object):
         data_list.append(val)
         self.data[name] = data_list
 
-    def put_filename(self, val):
-        self.put('filename', val)
+    def set_filename(self, val):
+        self.set('filename', val)
 
     def put_areas(self, val):
         self.put('areas', val)

femagtools/dxfsl/machine.py

@@ -5,14 +5,16 @@
 from __future__ import print_function
 import numpy as np
 import logging
-from .shape import Element, Circle, Arc, Line, Shape
-from .corner import Corner
+from femagtools.dxfsl.shape import Element, Circle, Arc, Line, Shape
+from femagtools.dxfsl.corner import Corner
 from femagtools.dxfsl.symmetry import Symmetry
-from .functions import point, points_are_close, distance
-from .functions import alpha_angle, normalise_angle, middle_angle, third_angle
-from .functions import alpha_line, line_m, line_n, mirror_point
-from .functions import within_interval, part_of_circle
-from .functions import less, less_equal, greater, greater_equal
+import femagtools.dxfsl.area as AREA
+from femagtools.dxfsl.functions import point, points_are_close, distance
+from femagtools.dxfsl.functions import alpha_angle, normalise_angle, middle_angle, third_angle
+from femagtools.dxfsl.functions import alpha_line, line_m, line_n, mirror_point
+from femagtools.dxfsl.functions import within_interval, part_of_circle
+from femagtools.dxfsl.functions import less, less_equal, greater, greater_equal
+from femagtools.dxfsl.journal import Journal, getJournal
 logger = logging.getLogger('femagtools.geom')
 
 
@@ -37,6 +39,7 @@ class Machine(object):
         self.airgap2_radius = 0.0
         self.airgap_second = None
         self.previous_machine = None
+        self.journal = getJournal()
 
         if not self.center:
             raise ValueError("FATAL ERROR: no center in Geometry")
@@ -283,11 +286,6 @@ class Machine(object):
         logger.debug("end of copy_mirror")
         return machine
 
-    def has_mirrored_windings(self):
-        if not self.is_mirrored():
-            return False
-        return self.geom.area_close_to_endangle(2) > 0
-
     def undo_mirror(self):
         assert(self.is_mirrored())
         assert(self.previous_machine)
@@ -533,7 +531,7 @@ class Machine(object):
     def repair_hull_geom(self, geom, startangle, endangle):
         logger.debug('begin repair_hull_geom (%s, %s)', startangle, endangle)
 
-        rtol = 1e-4
+        rtol = 1e-3
         atol = 1e-4
         c_corner = Corner(self.center, self.center)
         start_c_added, start_corners = geom.get_corner_list(self.center, startangle,
@@ -558,8 +556,9 @@ class Machine(object):
                               rtol=rtol, atol=atol)
         logger.debug('end of repair_hull_geom')
 
-    def create_boundery_nodes(self):
-        self.geom.create_boundery_nodes(self.center, self.startangle, self.endangle)
+    def create_boundary_nodes(self):
+        if self.geom.create_boundary_nodes(self.center, self.startangle, self.endangle):
+            logger.debug("___additional boundary nodes created___")
 
     def create_auxiliary_lines(self):
         logger.debug("create_auxiliary_lines")
@@ -1138,6 +1137,11 @@ class Machine(object):
 
         return 0.0
 
+    def has_windings_in_the_middle(self):
+        midangle = middle_angle(self.startangle,
+                                self.endangle)
+        return self.geom.windings_in_the_middle(midangle)
+
     def create_mirror_lines_outside_windings(self):
         logger.debug("create_mirror_lines_outside_windings")
 

femagtools/dxfsl/shape.py

@@ -54,6 +54,9 @@ class Shape(object):
     def classname(self):
         return "Shape"
 
+    def set_my_color(self, color):
+        self.my_color = color
+
     def get_my_color(self):
         if hasattr(self, 'my_color'):
             return self.my_color