femagtools 1.6.5__py3-none-any.whl → 1.6.6__py3-none-any.whl

femagtools/__init__.py

@@ -2,7 +2,7 @@
 
 """
 __title__ = 'femagtools'
-__version__ = '1.6.5'
+__version__ = '1.6.6'
 __author__ = 'Ronald Tanner'
 __license__ = 'BSD'
 __copyright__ = 'Copyright 2016-2022 SEMAFOR Informatik & Energie AG'

femagtools/dxfsl/area.py

@@ -45,6 +45,7 @@ class Area(object):
         self.mag_rectangle = False
         self.min_dist = 99999.0
         self.max_dist = 0.0
+        self.minmax_xy = [0,0,0,0]
         self.height = 0.0
         self.alpha = 0.0
         self.count = 1
@@ -269,6 +270,7 @@ class Area(object):
         if not self.area:
             return
 
+        self.minmax_xy = self.minmax()
         s = self.area[0]
         mm_angle = s.minmax_angle_from_center(center)
         self.min_angle = mm_angle[0]
@@ -286,6 +288,12 @@ 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]:
+            return True
+        return False
+
     def minmax_angle_dist_from_center(self, center, dist):
         circ = Circle(Element(center=center, radius=dist))
         s = self.area[0]
@@ -429,10 +437,14 @@ class Area(object):
                 (the_axis_p[0], the_axis_p[1]),
                 (the_area_p[0], the_area_p[1]))
 
-    def get_alpha(self):
+    def get_alpha(self, center):
+        if self.center_is_inside(center):
+            return np.pi*2.0
         return alpha_angle(self.min_angle, self.max_angle)
 
-    def get_mid_angle(self):
+    def get_mid_angle(self, center):
+        if self.center_is_inside(center):
+            return np.pi
         return middle_angle(self.min_angle, self.max_angle)
 
     def is_equal(self, a, sym_tolerance):
@@ -636,7 +648,7 @@ class Area(object):
         return False
 
     def get_best_point_inside(self, geom):
-        mm = self.minmax()
+        mm = self.minmax_xy
         px1 = mm[0]-5
         px2 = mm[1]+5
 
@@ -733,7 +745,7 @@ class Area(object):
 
     def get_point_inside(self, geom):
         """return point inside area"""
-        mm = self.minmax()
+        mm = self.minmax_xy
         y = (mm[2]+mm[3])/2
         p1 = (mm[0]-5, y)
         p2 = (mm[1]+5, y)
@@ -1466,6 +1478,14 @@ class Area(object):
                     self.close_to_ag_endcorner = True
 
     def area_size(self):
+        if len(self.area) == 0:
+            return 0.0
+        if self.number_of_elements() < 2:
+            e = self.area[0]
+            if not is_Circle(e):
+                return 0.0
+            return np.pi * e.radius**2
+
         nodes = [n for n in self.list_of_nodes()]
         return area_size(nodes)
 

femagtools/dxfsl/areabuilder.py

@@ -341,9 +341,11 @@ class AreaBuilder(object):
     def __init__(self,
                  geom=None,
                  rtol=1e-04,
-                 atol=1e-04):
+                 atol=1e-04,
+                 ndec=6):
         self.rtol = rtol
         self.atol = atol
+        self.ndec = ndec
         self.geom = geom
         self.area_list = []
         self.journal = getJournal()
@@ -358,7 +360,13 @@ class AreaBuilder(object):
 
     def set_edge_attributes(self):
         self.geom.set_edge_attributes()
-    
+
+    def append_new_area(self, area_list, elements):
+        a = Area(elements, self.geom.center, 0.0)
+        a.type = 0  # air
+        area_list.append(a)
+        return a
+
     def create_list_of_areas(self, main=False):
         logger.debug("Begin of create_list_of_areas")
         assert(len(self.area_list) == 0)
@@ -382,10 +390,8 @@ class AreaBuilder(object):
                 for next_n in nbrs:
                     result = self.get_new_area(n, next_n)
                     if result['ok']:
-                        area = result['area']
-                        a = Area(area, self.geom.center, 0.0)
+                        a = self.append_new_area(self.area_list, result['area'])
                         logger.debug("Area %s found", a.identifier())
-                        append(self.area_list, a)
 
         t = timer.stop("{} areas created in %0.4f seconds".format(len(self.area_list)))
         if main:
@@ -564,3 +570,144 @@ class AreaBuilder(object):
         nbr1.log_edge(">>>> LEFT")
         logger.debug("end of next_edge_lefthand_side")
         return nbr1
+
+    def create_inner_corner_auxiliary_areas(self):
+        logger.debug("begin of create_inner_corner_auxiliary_areas")
+        if not self.geom.is_inner:
+            logger.debug("end of create_inner_corner_auxiliary_areas: not inner")
+            return
+
+        self.set_edge_attributes()
+
+        start_cp, start_exists = self.geom.get_start_airgap_corner()
+        end_cp, end_exists = self.geom.get_end_airgap_corner()
+        if start_exists and end_exists:
+            logger.debug("end of create_inner_corner_auxiliary_areas: no aktion")
+            return
+
+        airgap_line, airgap_el = self.get_inner_airgap_line()
+        if not airgap_el:
+            logger.debug("end of create_inner_corner_auxiliary_areas: no airgapline found")
+            return
+
+        logger.debug("airgapline found !!")
+        airgap_nodes = [n for n in airgap_line[1:]]
+        del airgap_nodes[-1]
+
+        if not start_exists:
+            cp = self.geom.start_corners[-1]
+            logger.debug("Start Corner: %s -- %s", cp, start_cp)
+            start_line = Line(Element(start=cp, end=start_cp),
+                              color='red',
+                              linestyle='dotted')
+
+            start_cp = start_line.node2(self.ndec)
+            for n in airgap_nodes:
+                ag_line = Line(Element(start=start_cp, end=n))
+                points = self.geom.get_intersection_points(airgap_el, ag_line, n)
+                if not points:  # no intersection
+                    d = distance(self.geom.center, n)
+                    if np.isclose(d, self.geom.max_radius):
+                        self.geom.add_arc(start_cp,
+                                          n,
+                                          self.geom.center,
+                                          self.geom.max_radius,
+                                          color='red',
+                                          linestyle='dotted')
+                    else:
+                        self.geom.add_line(start_cp,
+                                           n,
+                                           color='red',
+                                           linestyle='dotted')
+                    self.geom.add_edge(cp, start_cp, start_line)
+                    result = self.get_new_area(start_cp, n)
+                    if result['ok']:
+                        self.append_new_area(self.geom.area_list,
+                                             result['area'])
+                    self.geom.set_start_corners(self.geom.center, 0.0)
+                    break
+
+        if not end_exists:
+            cp = self.geom.end_corners[-1]
+            logger.debug("End Corner: %s -- %s", cp, end_cp)
+            end_line = Line(Element(start=cp, end=end_cp),
+                            color='red',
+                            linestyle='dotted')
+            end_cp = end_line.node2(self.ndec)
+            airgap_nodes.reverse()
+            for n in airgap_nodes:
+                ag_line = Line(Element(start=end_cp, end=n))
+                points = self.geom.get_intersection_points(airgap_el, ag_line, n)
+                if not points:  # no intersection
+                    d = distance(self.geom.center, n)
+                    if np.isclose(d, self.geom.max_radius):
+                        self.geom.add_arc(n, end_cp,
+                                          self.geom.center,
+                                          self.geom.max_radius,
+                                          color='red',
+                                          linestyle='dotted')
+                    else:
+                        self.geom.add_line(end_cp, n,
+                                           color='red',
+                                           linestyle='dotted')
+                    self.geom.add_edge(cp, end_cp, end_line)
+                    result = self.get_new_area(n, end_cp)
+                    if result['ok']:
+                        self.append_new_area(self.geom.area_list,
+                                             result['area'])
+                    self.geom.set_end_corners(self.geom.center, self.geom.alfa)
+                    break
+
+        logger.debug("end of create_inner_corner_auxiliary_areas")
+
+    def get_inner_airgap_line(self):
+        logger.debug("begin of get_inner_airgap_line")
+        assert(self.geom.is_inner)
+        assert(self.geom.area_list)
+
+        area = [a for a in self.geom.area_list if a.close_to_ag_endcorner]
+        if len(area) != 1:
+            logger.debug("end of get_inner_airgap_line: %s areas found", len(area))
+            return [], []
+
+        end_corner = self.geom.end_corners[-1]
+        logger.debug("END CORNER %s", end_corner)
+
+        nodes = [n for n in area[0].list_of_nodes()]
+        if not nodes:
+            logger.debug("end of get_inner_airgap_line: no nodes found")
+            return [], []
+
+        n1 = nodes[0]
+        if points_are_close(end_corner, n1):
+            n2 = nodes[-1]
+        else:
+            n2 = n1
+            for n1 in nodes[1:]:
+                if points_are_close(end_corner, n1):
+                    break
+                n2 = n1
+
+        if not points_are_close(end_corner, n1):
+            logger.debug("end of get_inner_airgap_line: not close to endcorner")
+            return [], []
+
+        start_corner = self.geom.start_corners[-1]
+        logger.debug("START CORNER %s", end_corner)
+
+        logger.debug("EDGE FOUND: %s - %s", n1, n2)
+        nodes = [n1, n2]
+        info = self.get_edge_info(n1, n2)
+        elements = [info.element]
+
+        while not points_are_close(start_corner, n2):
+            info.set_start_angle()
+            info = self.next_edge_lefthand_side(info)
+            if not info:  # bad
+                return []
+            n2 = info.n2
+            nodes.append(n2)
+            elements.append(info.element)
+
+        logger.debug("end of get_inner_airgap_line #%s", len(nodes))
+        return nodes, elements

femagtools/dxfsl/concat.py

@@ -204,9 +204,9 @@ class Concatenation(object):
         elmts.sort()
 
         logger.debug("Concatenate Line Elements")
-        for m, a, p, e in elmts:
-            logger.debug("Line from %s to %s [m=%s, a=%s]",
-                         e.p1, e.p2, m, a)
+        #for m, a, p, e in elmts:
+        #    logger.debug("Line from %s to %s [m=%s, a=%s]",
+        #                 e.p1, e.p2, m, a)
         logger.debug("*************************")
 
         lines_available = len(elmts)
@@ -281,9 +281,9 @@ class Concatenation(object):
         elmts.sort()
 
         logger.debug("Concatenate Arc Elements")
-        for c, r, a, e in elmts:
-            logger.debug("%s from %s to %s [c=%s, r=%s, a=%s]",
-                         e.classname(), e.p1, e.p2, c, r, a)
+        #for c, r, a, e in elmts:
+        #    logger.debug("%s from %s to %s [c=%s, r=%s, a=%s]",
+        #                 e.classname(), e.p1, e.p2, c, r, a)
         logger.debug("*************************")
  
         arcs_available = len(elmts)
@@ -354,4 +354,4 @@ class Concatenation(object):
             self.journal.put('time_concatenation', t)
 
         logger.debug("End of concatenate_matching_elements")
-        return count>0, new_list
+        return count, new_list

femagtools/dxfsl/converter.py

@@ -1,11 +1,12 @@
 """read a dxf file and create a plot or fsl file
 
 """
-import os
-from femagtools.dxfsl.geom import Geometry, dxfshapes, femshapes
+from pathlib import Path
+from femagtools.dxfsl.geom import Geometry
 from femagtools.dxfsl.shape import Shape
 from femagtools.dxfsl.fslrenderer import FslRenderer, agndst
 from femagtools.dxfsl.plotrenderer import PlotRenderer
+from femagtools.dxfsl.functions import Timer
 import logging
 import logging.config
 import numpy as np
@@ -124,8 +125,9 @@ def convert(dxfile,
     layers = ()
     conv = {}
 
-    basename = os.path.basename(dxfile).split('.')[0]
-    logger.info("start processing %s", basename)
+    basename = Path(dxfile).stem
+    logger.info("***** start processing %s *****", basename)
+    timer = Timer(start_it=True)
 
     if part:
         if part[0] not in ('rotor', 'stator'):
@@ -149,18 +151,28 @@ def convert(dxfile,
         split_cpy = split
 
     try:
-        if dxfile.split('.')[-1] == 'fem':
+        if Path(dxfile).suffix == '.fem':
+            from .femparser import femshapes
             basegeom = Geometry(femshapes(dxfile),
                                 rtol=rtol,
                                 atol=atol,
                                 split=split_ini)
-        else:
+        elif Path(dxfile).suffix == '.dxf':
+            from .dxfparser import dxfshapes
             basegeom = Geometry(dxfshapes(dxfile,
                                           mindist=mindist,
                                           layers=layers),
                                 rtol=rtol,
                                 atol=atol,
                                 split=split_ini)
+        elif Path(dxfile).suffix == '.svg':
+            from .svgparser import svgshapes
+            basegeom = Geometry(svgshapes(dxfile),
+                                rtol=rtol,
+                                atol=atol,
+                                split=split_ini)
+
+
     except FileNotFoundError as ex:
         logger.error(ex)
         return dict()
@@ -187,7 +199,7 @@ def convert(dxfile,
     machine_base = basegeom.get_machine()
     if show_plots:
         p.render_elements(basegeom, Shape,
-                          title=os.path.basename(dxfile),
+                          title=Path(dxfile).name,
                           with_hull=False,
                           rows=3, cols=2, num=1, show=debug_mode)
 
@@ -490,6 +502,7 @@ def convert(dxfile,
                 conv.update(params)
 
     conv['name'] = basename
+    timer.stop("-- all done in %0.4f seconds --")
     return conv