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

femagtools/dxfsl/geom.py

@@ -19,6 +19,7 @@ from .area import Area
 from .shape import Element, Shape, Circle, Arc, Line, Point
 from .shape import is_Circle, is_Arc, is_Line
 from .machine import Machine
+from femagtools.dxfsl.areabuilder import AreaBuilder
 from .functions import less_equal, less, greater, greater_equal
 from .functions import distance, alpha_line, alpha_points, alpha_angle
 from .functions import point, points_are_close, is_point_inside_region
@@ -251,432 +252,6 @@ def intersect(a, b):
         ccw(b.p1, b.p2, a.p1) != ccw(b.p1, b.p2, a.p2)
 
 
-def polylines(entity, lf, rf, xoff=0.0, yoff=0.0, rotation=0.0):
-    """returns a collection of bulged vertices
-    http://www.afralisp.net/archive/lisp/Bulges1.htm
-    """
-    if isinstance(entity.points, list):
-        points = [(p[0], p[1]) for p in entity.points]
-    else:
-        points = [(p[0], p[1]) for p in entity.points()]
-    i = 0
-    if isinstance(entity.vertices, list):
-        vertices = entity.vertices
-    else:
-        vertices = entity.vertices()
-
-    for v in vertices:
-        if hasattr(v, 'bulge'):
-            b = v.bulge
-        else:
-            b = v.get_dxf_attrib('bulge', 0.0)
-        p1 = points[i]
-        try:
-            p2 = points[i+1]
-        except Exception:
-            if not entity.is_closed:
-                break
-            p2 = points[0]
-        if b != 0.0:
-            dx, dy = p2[0] - p1[0], p2[1] - p1[1]
-            c = np.sqrt(dx**2 + dy**2)
-            s = b * c/2
-            r = ((c/2)**2 + s**2)/2/s
-            g = np.arctan2(dx, dy)
-            a = 2*np.arctan(b)
-            pc = (p1[0] + r*np.sin(g - np.pi/2 + a),
-                  p1[1] + r*np.cos(g - np.pi/2 + a))
-            if b < 0:
-                sa = np.arctan2(p2[1]-pc[1], p2[0]-pc[0])
-                ea = np.arctan2(p1[1]-pc[1], p1[0]-pc[0])
-            else:
-                sa = np.arctan2(p1[1]-pc[1], p1[0]-pc[0])
-                ea = np.arctan2(p2[1]-pc[1], p2[0]-pc[0])
-            logger.debug("Poly p1 %s p2 %s r %s", p1, p2, r)
-            yield Arc(Element(center=(pc[0], pc[1]),
-                              radius=np.abs(r),
-                              start_angle=sa/rf,
-                              end_angle=ea/rf),
-                      lf, rf,
-                      xoff=xoff, yoff=yoff,
-                      rotation=rotation)
-        else:
-            yield Line(Element(start=p1, end=p2), lf,
-                       xoff=xoff, yoff=yoff,
-                       rotation=rotation)
-        i += 1
-
-
-def lw_polyline(entity, lf, xoff=0.0, yoff=0.0, rotation=0.0):
-    """returns a collection of bulged vertices
-    http://www.afralisp.net/archive/lisp/Bulges1.htm
-    """
-    if isinstance(entity.points, list):
-        points = [(lf*p[0], lf*p[1]) for p in entity.points]
-    else:
-        points = [(lf*p[0], lf*p[1]) for p in entity.points()]
-
-    if points:
-        p1 = points[0]
-        for p2 in points[1:]:
-            yield Line(Element(start=p1, end=p2), lf,
-                       xoff=xoff, yoff=yoff,
-                       rotation=rotation)
-            p1 = p2
-    if entity.is_closed:
-        yield Line(Element(start=p1, end=points[0]), lf,
-                   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
-    theta = np.arctan2(entity.major_axis[1], entity.major_axis[0])
-    start_angle = entity.start_param
-    end_angle = entity.end_param
-    if end_angle < start_angle:
-        end_angle += 2*np.pi
-    alfa = np.linspace(start_angle, end_angle, 20)
-    x = 0.5 * w * np.cos(alfa)
-    y = 0.5 * h * np.sin(alfa)
-    R = np.array([
-        [np.cos(theta), -np.sin(theta)],
-        [np.sin(theta),  np.cos(theta)]
-    ])
-    x, y = np.dot(R, [x, y])
-    x += entity.center[0]
-    y += entity.center[1]
-    points = np.array((x, y)).T
-    p1 = points[0]
-    for p2 in points[1:]:
-        yield Line(Element(start=p1, end=p2), lf,
-                   xoff=xoff, yoff=yoff,
-                   rotation=rotation)
-        p1 = p2
-
-
-def spline(entity, lf, min_dist=0.001, xoff=0.0, yoff=0.0, rotation=0.0):
-    if False:
-        yield Line(Element(start=entity.control_points[0],
-                           end=entity.control_points[-1]), lf,
-                   xoff=xoff, yoff=yoff,
-                   rotation=rotation)
-        return
-
-    if False:
-        p_prev = None
-        for p in entity.control_points:
-            if p_prev:
-                yield Line(Element(start=p_prev, end=p), lf,
-                           xoff=xoff, yoff=yoff,
-                           rotation=rotation)
-            p_prev = p
-        return
-
-    points_between = entity.control_points[1:-1]
-    p1 = entity.control_points[0]
-    pe = entity.control_points[-1]
-    for p2 in points_between:
-        dist_12 = distance(p1, p2)
-        dist_2e = distance(p2, pe)
-        if dist_2e < min_dist:
-            logger.debug("SPLINE: ignor small end-distance %s", dist_2e)
-            yield Line(Element(start=p1, end=pe), lf,
-                       xoff=xoff, yoff=yoff,
-                       rotation=rotation)
-            return
-
-        if dist_12 > min_dist:
-            yield Line(Element(start=p1, end=p2), lf,
-                       xoff=xoff, yoff=yoff,
-                       rotation=rotation)
-            p1 = p2
-        else:
-            logger.debug("SPLINE: ignor small distance %s", dist_12)
-
-    yield Line(Element(start=p1, end=pe), lf,
-               xoff=xoff, yoff=yoff,
-               rotation=rotation)
-
-
-def face3d(entity, lf):
-    logger.info("FACE3D: Points=%s", entity.points)
-    for i in range(len(entity.points)-1):
-        if not entity.is_edge_invisible(i):
-            ip = i+1 if i < 4 else 0
-            yield Line(Element(start=(entity.points[i][1],
-                                      entity.points[i][2]),
-                               end=(entity.points[ip][1],
-                                    entity.points[ip][2])))
-
-
-def insert_block(dwg, insert_entity, lf, rf, block, min_dist=0.001):
-    logger.debug('Insert %s entities from block %s',
-                 len(block),
-                 insert_entity.name)
-    logger.debug('Insert = %s', insert_entity.insert)
-    logger.debug('Rotation = %s', insert_entity.rotation)
-    logger.debug('Scale = %s', insert_entity.scale)
-    logger.debug('Rows = %s', insert_entity.row_count)
-    logger.debug('Cols = %s', insert_entity.col_count)
-    logger.debug('Row spacing = %s', insert_entity.row_spacing)
-    logger.debug('Col spacing = %s', insert_entity.col_spacing)
-
-    if insert_entity.insert != (0.0, 0.0, 0.0):
-        logger.debug('Different Location in Insert')
-
-    xoff = insert_entity.insert[0]
-    yoff = insert_entity.insert[1]
-
-    scale = (round(insert_entity.scale[0], 8),
-             round(insert_entity.scale[1], 8),
-             round(insert_entity.scale[2], 8))
-    if not (scale == (1.0, 1.0, 1.0) or
-            scale == (1.0, 1.0, 0.0)):
-        logger.error('Block scaling in Insert not supported')
-        logger.error('  scale = {}'.format(scale))
-        return
-
-    if(insert_entity.row_count > 1 or
-       insert_entity.col_count > 1 or
-       insert_entity.row_spacing > 0 or
-       insert_entity.col_spacing > 0):
-        logger.error('Multi Block references in Insert not supported')
-        return
-
-    for e in block:
-        if e.dxftype == 'ARC':
-            logger.debug("Block Arc")
-            yield Arc(e, lf, rf,
-                      xoff=xoff, yoff=yoff,
-                      rotation=insert_entity.rotation)
-        elif e.dxftype == 'CIRCLE':
-            logger.debug("Block Circle %s, Radius %f", e.center[:2], e.radius)
-            yield Circle(e, lf,
-                         xoff=xoff, yoff=yoff,
-                         rotation=insert_entity.rotation)
-        elif e.dxftype == 'LINE':
-            logger.debug("Block Line")
-            yield Line(e, lf,
-                       xoff=xoff, yoff=yoff,
-                       rotation=insert_entity.rotation)
-        elif e.dxftype == 'POLYLINE':
-            logger.debug("Block Polyline")
-            for p in polylines(e, lf, rf,
-                               xoff=xoff, yoff=yoff,
-                               rotation=insert_entity.rotation):
-                yield p
-        elif e.dxftype == 'LWPOLYLINE':
-            logger.debug("Block lwPolyline")
-            for p in lw_polyline(e, lf,
-                                 xoff=xoff, yoff=yoff,
-                                 rotation=insert_entity.rotation):
-                yield p
-        elif e.dxftype == 'SPLINE':
-            logger.debug("Block spline")
-            for l in spline(e, lf,
-                            min_dist=min_dist,
-                            xoff=xoff, yoff=yoff,
-                            rotation=insert_entity.rotation):
-                yield l
-        elif e.dxftype == 'INSERT':
-            logger.debug("Nested Insert of Block %s", e.name)
-            block = dwg.blocks[e.name]
-            for l in insert_block(dwg, e, lf, rf, block, min_dist=min_dist):
-                yield l
-
-        else:
-            logger.warn("unknown type %s in block %s",
-                        e.dxftype, insert_entity.name)
-
-
-def dxfshapes0(dxffile, mindist=0.01, layers=[]):
-    """returns a collection of dxf entities (ezdxf)"""
-    import ezdxf
-    dwg = ezdxf.readfile(dxffile)
-    id = 0
-    # $ACADVER: AC1006 = R10, AC1009 = R11 and R12, AC1012 = R13,
-    #   AC1014 = R14 AC1015 = Release 2000/0i/2
-    # check units:
-    # dwg.header['$ANGDIR'] 1 = Clockwise angles, 0 = Counterclockwise
-    # dwg.header['$AUNITS'] 0 Decimal Degrees, 1 Deg/Min/Sec, 2 Grads, 3 Radians
-    # dwg.header['$INSUNIT'] 1 = Inches; 2 = Feet; 3 = Miles;
-    #   4 = Millimeters; 5 = Centimeters; 6 = Meters
-    # dwg.header['$LUNITS']
-    for e in dwg.modelspace():
-        if e.dxftype() == 'ARC':
-            yield Arc(e.dxf)
-        elif e.dxftype() == 'CIRCLE':
-            logger.debug("Circle %s, Radius %f", e.center[:2], e.radius)
-            yield Circle(e.dxf)
-        elif e.dxftype() == 'LINE':
-            yield Line(e.dxf)
-        elif e.dxftype() == 'POLYLINE':
-            for p in polylines(e):
-                yield p
-        elif e.dxftype() == 'SPLINE':
-            for l in spline(e, 1.0, in_dist=mindist):
-                yield l
-        elif e.dxftype() == 'POINT':
-            logger.debug("Id %d4: type %s ignored", id, e.dxftype)
-        else:
-            logger.warning("Id %d4: unknown type %s", id, e.dxftype)
-        id += 1
-
-
-def dxfshapes(dxffile, mindist=0.01, layers=[]):
-    """returns a collection of dxf entities (dxfgrabber)"""
-    import dxfgrabber
-    dwg = dxfgrabber.readfile(dxffile)
-    # print("Layers = {}".format(dwg.layers.names()))
-    id = 0
-    # $ACADVER: AC1006 = R10, AC1009 = R11 and R12, AC1012 = R13,
-    #   AC1014 = R14 AC1015 = Release 2000/0i/2
-    # check units:
-    # dwg.header['$ANGDIR'] 1 = Clockwise angles, 0 = Counterclockwise
-    # dwg.header['$AUNITS'] Decimal Degrees, Deg/Min/Sec, Grads, Radians
-    # dwg.header['$INSUNIT'] 1 = Inches; 2 = Feet; 3 = Miles;
-    #   4 = Millimeters; 5 = Centimeters; 6 = Meters
-    # 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]
-        lf = 2.54e3
-
-    rf = np.pi/180
-    if dwg.header.get('$AUNITS', 0) == 4:
-        rf = 1
-
-    for e in dwg.modelspace():
-        if not layers or e.layer in layers:
-            if e.dxftype == 'ARC':
-                yield Arc(e, lf, rf)
-            elif e.dxftype == 'CIRCLE':
-                logger.debug("Circle %s, Radius %f", e.center[:2], e.radius)
-                yield Circle(e, lf)
-            elif e.dxftype == 'LINE':
-                yield Line(e, lf)
-            elif e.dxftype == 'POLYLINE':
-                for p in polylines(e, lf, rf):
-                    yield p
-            elif e.dxftype == 'LWPOLYLINE':
-                for p in lw_polyline(e, lf):
-                    yield p
-            elif e.dxftype == 'SPLINE':
-                for l in spline(e, lf, min_dist=mindist):
-                    yield l
-            elif e.dxftype == 'INSERT':
-                logger.debug("Insert of Block %s", e.name)
-                block = dwg.blocks[e.name]
-                for l in insert_block(dwg, e, lf, rf, block, min_dist=mindist):
-                    yield l
-            elif e.dxftype == 'ELLIPSE':
-                for l in ellipse(e, lf):
-                    yield l
-                #w = np.linalg.norm(e.major_axis) * 2
-                #h = e.ratio * w
-                #rtheta = np.arctan2(e.major_axis[1], e.major_axis[0])
-                #angle = rtheta*180/np.pi
-                #start_angle = e.start_param*180/np.pi + angle
-                #end_angle = e.end_param*180/np.pi + angle
-                #if end_angle < start_angle:
-                #    end_angle += 360
-                #arc = Arc(Element(center=e.center,
-                #                  radius=w/2,
-                #                  start_angle=start_angle,
-                #                  end_angle=end_angle,
-                #                  width=w,
-                #                  height=h,
-                #                  rtheta=rtheta,
-                #                  start_param=e.start_param,
-                #                  end_param=e.end_param))
-                #yield arc
-
-            elif e.dxftype == 'POINT':
-                logger.debug("Id %d4: type %s ignored", id, e.dxftype)
-            elif e.dxftype == '3DFACE':
-                logger.warning(
-                    "Id %d4: type %s not implemented", id, e.dxftype)
-                # for l in face3d(e, lf):
-                #     yield l
-            else:
-                logger.warning("Id %d4: unknown type %s", id, e.dxftype)
-            id += 1
-
-
-fem_points = []
-
-
-def read_fem_points(f, num):
-    for x in range(num):
-        p = f.readline().split()
-        fem_points.append([float(p[0]), float(p[1])])
-
-
-def read_fem_lines(f, num):
-    for x in range(num):
-        p = f.readline().split()
-        i1 = int(p[0])
-        i2 = int(p[1])
-        p1 = fem_points[i1]
-        p2 = fem_points[i2]
-        if points_are_close(p1, p2):
-            logger.warning("FEMM: Line with points close together")
-            logger.warning("      p1 = %s, p2 =%s", p1, p2)
-        yield Line(Element(start=p1, end=p2))
-
-
-def read_fem_arcs(f, num):
-    for x in range(num):
-        p = f.readline().split()
-        i1 = int(p[0])
-        i2 = int(p[1])
-        alpha = float(p[2])
-        p1 = fem_points[i1]
-        p2 = fem_points[i2]
-        if points_are_close(p1, p2):
-            logger.warning("FEMM: Arc with points close together")
-            logger.warning("      p1 = %s, p2 = %s", p1, p2)
-        for e in get_fem_arc(p1, p2, alpha):
-            yield e
-
-
-def get_fem_arc(pA, pB, alfa):
-    alpha = alfa/180.0*np.pi/2.0
-    y = distance(pA, pB) / 2.0
-    x = y / np.tan(alpha)
-    r = np.sqrt(x**2 + y**2)
-
-    delta = alpha_line(pA, pB)
-
-    c = [pA[0] + y, pA[1] + x]
-    phi = alpha_line(pA, c) + delta
-    pC = point_on_arc(pA, r, phi)
-
-    startangle = alpha_line(pC, pA)
-    endangle = alpha_line(pC, pB)
-    yield Arc(Element(center=pC,
-                      radius=r,
-                      start_angle=startangle*180/np.pi,
-                      end_angle=endangle*180/np.pi))
-
-
-def femshapes(femfile):
-    f = open(femfile, 'r')
-
-    for data in f:
-        text = data.split()
-        if text[0] == '[NumPoints]':
-            read_fem_points(f, int(text[2]))
-        elif text[0] == '[NumSegments]':
-            for e in read_fem_lines(f,  int(text[2])):
-                yield e
-        elif text[0] == '[NumArcSegments]':
-            for e in read_fem_arcs(f,  int(text[2])):
-                yield e
-
-
 def is_connected(a, b):
     if a == b:
         return False
@@ -1079,6 +654,14 @@ class Geometry(object):
         return [n[1]['object'] for n in self.g.nodes(data=True)
                 if n[1] and isinstance(n[1]['object'], Circle)]
 
+    def nodes(self):
+        for n in self.g.nodes():
+            yield n
+
+    def get_nodes(self):
+        nodes = [n for n in self.g.nodes()]
+        return nodes
+
     def virtual_nodes(self):
         nodes = []
         for e in self.elements(Shape):
@@ -1696,6 +1279,11 @@ class Geometry(object):
             # list already available
             return
 
+        areabuilder = AreaBuilder(geom=self)
+        areabuilder.create_list_of_areas(main=False)
+        self.area_list = areabuilder.area_list
+        return
+
         def append(area_list, a):
             for area in area_list:
                 if area.is_identical(a):

femagtools/dxfsl/journal.py

@@ -55,7 +55,6 @@ class Journal(object):
         if not self.journal:
             return
         self.set_benchmark()
-
         with open(self.filename, 'w') as f:
             f.write(json.dumps(self.journal, indent=4))
             f.close()
@@ -69,18 +68,8 @@ class Journal(object):
 
         self.open_journal()
         self.data = self.journal.get(name, None)
-        if not self.data:
-            self.data = {'filename': "",
-                         'elements': 0,
-                         'nodes': 0,
-                         'concat_lines': 0,
-                         'concat_arcs': 0,
-                         'appendices': 0,
-                         'appendices_connected': 0,
-                         'appendices_remaining': 0,
-                         'areas': 0,
-                         'area_errors': 0}
-            self.journal[name] = self.data
+        self.data = {'filename': ""}  # initialise
+        self.journal[name] = self.data
         return self.data
 
     def set_benchmark(self):
@@ -88,19 +77,23 @@ class Journal(object):
             self.put_warning("Problem with areas")
         if self.data.get('appendices_deleted', 0) > 0:
             self.put_warning("Problem with appendices")
-          
+
     def put(self, name, val):
         if self.data:
             self.data[name] = val
 
+    def add(self, name, val):
+        if self.data:
+            self.data[name] = val + self.data.get(name, 0)
+
     def put_filename(self, val):
         self.put('filename', val)
 
     def put_areas(self, val):
-        self.put('areas', val)
+        self.add('areas', val)
 
     def put_area_errors(self, val):
-        self.put('area_errors', val)
+        self.add('area_errors', val)
 
     def put_elements(self, val):
         self.put('elements', val)
@@ -109,28 +102,27 @@ class Journal(object):
         self.put('nodes', val)
 
     def put_concat_lines(self, val):
-        self.put('concat_lines', val)
+        self.add('concat_lines', val)
 
     def put_concat_arcs(self, val):
-        self.put('concat_arcs', val)
+        self.add('concat_arcs', val)
 
     def put_appendices(self, val):
-        self.put('appendices', val)
+        self.add('appendices', val)
 
     def put_appendices_connected(self, val):
-        self.put('appendices_connected', val)
+        self.add('appendices_connected', val)
 
     def put_appendices_remaining(self, val):
-        self.put('appendices_remaining', val)
+        self.add('appendices_remaining', val)
 
     def put_appendices_deleted(self, val):
-        self.put('appendices_deleted', val)
+        self.add('appendices_deleted', val)
        
     def put_exception(self, msg):
         self.put('exception', msg)
 
     def put_warning(self, msg):
-        print(msg)
         lst = self.data.get('warning', [])
         lst.append(msg)
         self.put('warning', lst)

femagtools/dxfsl/machine.py

@@ -7,6 +7,7 @@ import numpy as np
 import logging
 from .shape import Element, Circle, Arc, Line
 from .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
@@ -592,9 +593,18 @@ class Machine(object):
         if self.radius <= 0.0:
             return False
 
-        found = self.geom.find_symmetry(self.radius,
-                                        self.startangle, self.endangle,
-                                        sym_tolerance)
+        symmetry = Symmetry(geom=self.geom,
+                            startangle=self.startangle,
+                            endangle=self.endangle)
+        parts = symmetry.find_symmetry()  # temp solution
+        logger.debug(">>> Symmetry parts = %s <<<", parts)
+
+        if parts > 1:
+            found = True
+        else:
+            found = self.geom.find_symmetry(self.radius,
+                                            self.startangle, self.endangle,
+                                            sym_tolerance)
         if not found and len(self.geom.area_list) < 5:
             if is_inner:
                 found = self.find_stator_symmetry(sym_tolerance, True)

femagtools/dxfsl/shape.py

@@ -1008,7 +1008,7 @@ class Arc(Circle):
         for p in points:
             alpha_p = alpha_line(center, p)
             alpha_min = min_angle(alpha_min, alpha_p)
-            alpha_max = min_angle(alpha_max, alpha_p)
+            alpha_max = max_angle(alpha_max, alpha_p)
 
         return (alpha_min, alpha_max)
 
@@ -1305,8 +1305,18 @@ class Line(Shape):
         return (dist_min, dist_max)
 
     def minmax_angle_from_center(self, center):
-        alpha_p1 = alpha_line(center, self.p1)
-        alpha_p2 = alpha_line(center, self.p2)
+        if points_are_close(center, self.p1):
+            alpha_p1 = None
+        else:
+            alpha_p1 = alpha_line(center, self.p1)
+        if points_are_close(center, self.p2):
+            alpha_p2 = None
+        else:
+            alpha_p2 = alpha_line(center, self.p2)
+        if alpha_p1 is None:
+            alpha_p1 = alpha_p2
+        if alpha_p2 is None:
+            alpha_p2 = alpha_p1
         if alpha_angle(alpha_p1, alpha_p2) < np.pi:
             return (alpha_p1, alpha_p2)
         else: