Merge pull request #15 from dzimmanck/feature/change_to_mm

Feature/change to mm

Author: dzimmanck

CHANGELOG.md

@@ -11,7 +11,17 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 
--Minor code cleanups
+## [v0.1.4]
+
+### Fixed
+
+### Added
+-Change convention to assume dimensions are specified in mm rather than m
+-Add support for coreloss calculations
+-Add support for more complex CAD part generation for cores
+-Minor code cleanups and API changes
+-Some documentation cleanup
+-Change the estimate_est method to be inherited from a base Winding class and to use materials
 
 ## [v0.1.3]
 

planar_magnetics/cores/cores.py

@@ -53,6 +53,20 @@ def calculate_core_extension(area: float, radius: float, opening_width: float) -
 
 
 class Core:
+    """A magnetic core object
+
+    Args:
+        centerpost_radius: The centerpost radius in mm
+        window_width: The winding window width in mm
+        window_height: The winding window height in mm
+        opening_width: The core termination opening widths in mm
+        gap: The core cap in mm
+
+    Attributes:
+        centerpost_area: The area of the centerpost in square mm
+        volume: The core volume in cubic mm
+    """
+
     def __init__(
         self,
         centerpost_radius: float,
@@ -108,6 +122,9 @@ def get_coreloss(
         """Calculate the coreloss using steinmetz parameters
         """
 
+        # This is not tested, so raise error
+        raise NotImplementedError
+
         k, alpha, beta = ferrite.get_steinmetz_parameters(temperature)
 
         Pv = k * f ** alpha * B ** beta
@@ -117,7 +134,7 @@ def get_coreloss(
     def to_parts(
         self,
         freecad_path: str = "C:/Program Files/FreeCAD 0.19/bin",
-        tol: float = 0.1e-3,
+        tol: float = 0.1,
         spacer_thickness: float = 0.0,
     ):
 
@@ -132,97 +149,82 @@ def to_parts(
         import Part
 
         # create the center piece
-        circle = Part.makeCircle(1e3 * self.centerpost_radius)
+        circle = Part.makeCircle(self.centerpost_radius)
         wire = Part.Wire(circle)
         disk = Part.Face(wire)
-        centerpost = disk.extrude(cad.Vector(0, 0, 1e3 * self.window_height / 2))
+        centerpost = disk.extrude(cad.Vector(0, 0, self.window_height / 2))
         to_gap = self.centerpost_radius + self.window_width / 2 - self.gap / 2
-        circle = Part.makeCircle(
-            1e3 * to_gap, cad.Vector(0, 0, 1e3 * self.window_height / 2)
-        )
+        circle = Part.makeCircle(to_gap, cad.Vector(0, 0, self.window_height / 2))
         wire = Part.Wire(circle)
         disk = Part.Face(wire)
-        topplate = disk.extrude(cad.Vector(0, 0, 1e3 * self.plate_thickness))
+        topplate = disk.extrude(cad.Vector(0, 0, self.plate_thickness))
         centerpiece = centerpost.fuse(topplate)
 
         # create the top plate
         square = Part.makePlane(
-            1e3 * self.width,
-            1e3 * self.width,
-            cad.Vector(
-                -1e3 * self.width / 2,
-                -1e3 * self.width / 2,
-                1e3 * self.window_height / 2,
-            ),
+            self.width,
+            self.width,
+            cad.Vector(-self.width / 2, -self.width / 2, self.window_height / 2,),
         )
         circle = Part.makeCircle(
-            1e3 * (to_gap + self.gap), cad.Vector(0, 0, 1e3 * self.window_height / 2)
+            to_gap + self.gap, cad.Vector(0, 0, self.window_height / 2)
         )
         wire = Part.Wire(circle)
         disk = Part.Face(wire)
         topplate_face = square.cut(disk)
-        topplate = topplate_face.extrude(cad.Vector(0, 0, 1e3 * self.plate_thickness))
+        topplate = topplate_face.extrude(cad.Vector(0, 0, self.plate_thickness))
 
         # create the legs
         opening_left_to_right = Part.makePlane(
-            1e3 * self.width,
-            1e3 * self.opening_width,
+            self.width,
+            self.opening_width,
             cad.Vector(
-                -1e3 * self.width / 2,
-                -1e3 * self.opening_width / 2,
-                1e3 * self.window_height / 2,
+                -self.width / 2, -self.opening_width / 2, self.window_height / 2,
             ),
         )
         opening_front_to_back = Part.makePlane(
-            1e3 * self.opening_width,
-            1e3 * self.width,
+            self.opening_width,
+            self.width,
             cad.Vector(
-                -1e3 * self.opening_width / 2,
-                -1e3 * self.width / 2,
-                1e3 * self.window_height / 2,
+                -self.opening_width / 2, -self.width / 2, self.window_height / 2,
             ),
         )
         circle = Part.makeCircle(
-            1e3 * self.outerpost_radius, cad.Vector(0, 0, 1e3 * self.window_height / 2),
+            self.outerpost_radius, cad.Vector(0, 0, self.window_height / 2),
         )
         wire = Part.Wire(circle)
         disk = Part.Face(wire)
         leg_face = square.cut(disk)
         legs_face = leg_face.cut(opening_left_to_right)
         legs_face = legs_face.cut(opening_front_to_back)
-        legs = legs_face.extrude(cad.Vector(0, 0, -1e3 * self.window_height / 2))
+        legs = legs_face.extrude(cad.Vector(0, 0, -self.window_height / 2))
 
         # fuse the legs to the top plate
         topplate = topplate.fuse(legs)
 
         # create the spacer
         circle = Part.makeCircle(
-            1e3 * (self.outerpost_radius - tol),
-            cad.Vector(0, 0, 1e3 * self.window_height / 2),
+            self.outerpost_radius - tol, cad.Vector(0, 0, self.window_height / 2),
         )
         wire = Part.Wire(circle)
         disk = Part.Face(wire)
         circle = Part.makeCircle(
-            1e3 * (self.centerpost_radius + tol),
-            cad.Vector(0, 0, 1e3 * self.window_height / 2),
+            self.centerpost_radius + tol, cad.Vector(0, 0, self.window_height / 2),
         )
         wire = Part.Wire(circle)
         cutout = Part.Face(wire)
         washer = disk.cut(cutout)
-        spacer = washer.extrude(cad.Vector(0, 0, -1e3 * spacer_thickness))
+        spacer = washer.extrude(cad.Vector(0, 0, -spacer_thickness))
         circle = Part.makeCircle(
-            1e3 * (to_gap + self.gap - tol),
-            cad.Vector(0, 0, 1e3 * self.window_height / 2),
+            to_gap + self.gap - tol, cad.Vector(0, 0, self.window_height / 2),
         )
         wire = Part.Wire(circle)
         disk = Part.Face(wire)
-        circle = Part.makeCircle(
-            1e3 * (to_gap + tol), cad.Vector(0, 0, 1e3 * self.window_height / 2)
-        )
+        circle = Part.makeCircle(to_gap + tol, cad.Vector(0, 0, self.window_height / 2))
         wire = Part.Wire(circle)
         cutout = Part.Face(wire)
         washer = disk.cut(cutout)
-        gap_spacer = washer.extrude(cad.Vector(0, 0, 1e3 * self.plate_thickness))
+        gap_spacer = washer.extrude(cad.Vector(0, 0, self.plate_thickness))
         spacer = spacer.fuse(gap_spacer)
 
         if not self.gap:
@@ -275,9 +277,7 @@ def to_step(
         # # bottom_half = top_half.mirror(cad.Vector(0, 0, 0), cad.Vector(0, 0, -1))
         part.exportStep(filename)
 
-    def create_pcb_cutouts(
-        self, center: Point = Point(0, 0), clearance: float = 0.5e-3
-    ):
+    def create_pcb_cutouts(self, center: Point = Point(0, 0), clearance: float = 0.5):
         """Generate cutout polygons"""
 
         # calculate the radius of the outer post cutouts
@@ -295,7 +295,7 @@ def create_pcb_cutouts(
         centerpost = Polygon(
             [Arc(center, self.centerpost_radius + clearance, -math.pi, math.pi)],
             "Edge.Cuts",
-            0.1e-3,
+            0.1,
             "none",
         )
 
@@ -308,31 +308,31 @@ def create_pcb_cutouts(
         corner1 = arc.end + Point(0, cutout_extension)
         corner3 = arc.start + Point(cutout_extension, 0)
         corner2 = Point(corner3.x, corner1.y)
-        leg1 = Polygon([arc, corner1, corner2, corner3], "Edge.Cuts", 0.1e-3, "none")
+        leg1 = Polygon([arc, corner1, corner2, corner3], "Edge.Cuts", 0.1, "none")
 
         start_angle += math.pi / 2
         end_angle += math.pi / 2
         arc = Arc(center, outer_cutout_radius, start_angle, end_angle)
         corner1 = arc.end + Point(-cutout_extension, 0)
         corner3 = arc.start + Point(0, cutout_extension)
         corner2 = Point(corner1.x, corner3.y)
-        leg2 = Polygon([arc, corner1, corner2, corner3], "Edge.Cuts", 0.1e-3, "none")
+        leg2 = Polygon([arc, corner1, corner2, corner3], "Edge.Cuts", 0.1, "none")
 
         start_angle += math.pi / 2
         end_angle += math.pi / 2
         arc = Arc(center, outer_cutout_radius, start_angle, end_angle)
         corner1 = arc.end + Point(0, -cutout_extension)
         corner3 = arc.start + Point(-cutout_extension, 0)
         corner2 = Point(corner3.x, corner1.y)
-        leg3 = Polygon([arc, corner1, corner2, corner3], "Edge.Cuts", 0.1e-3, "none")
+        leg3 = Polygon([arc, corner1, corner2, corner3], "Edge.Cuts", 0.1, "none")
 
         start_angle += math.pi / 2
         end_angle += math.pi / 2
         arc = Arc(center, outer_cutout_radius, start_angle, end_angle)
         corner1 = arc.end + Point(cutout_extension, 0)
         corner3 = arc.start + Point(0, -cutout_extension)
         corner2 = Point(corner1.x, corner2.y)
-        leg4 = Polygon([arc, corner1, corner2, corner3], "Edge.Cuts", 0.1e-3, "none")
+        leg4 = Polygon([arc, corner1, corner2, corner3], "Edge.Cuts", 0.1, "none")
 
         cutouts = [centerpost, leg1, leg2, leg3, leg4]
 
@@ -341,5 +341,5 @@ def create_pcb_cutouts(
 
 if __name__ == "__main__":
 
-    core = Core(8.6e-3, 6e-3, 6e-3, 3e-3, 0.5e-3)
+    core = Core(8.6, 6, 6, 3, 0.5)
     core.to_step("core.step")

planar_magnetics/creepage.py

@@ -33,25 +33,25 @@ def description(self):
 
 # Creepage table
 CREEPAGE_TABLE = {
-    15: [0.05e-3, 0.1e-3, 0.1e-3, 0.05e-3, 0.13e-3, 0.13e-3, 0.13e-3],
-    30: [0.05e-3, 0.1e-3, 0.1e-3, 0.05e-3, 0.13e-3, 0.25e-3, 0.13e-3],
-    50: [0.1e-3, 0.6e-3, 0.6e-3, 0.13e-3, 0.13e-3, 0.4e-3, 0.13e-3],
-    100: [0.1e-3, 0.6e-3, 1.5e-3, 0.13e-3, 0.13e-3, 0.5e-3, 0.13e-3],
-    150: [0.2e-3, 0.6e-3, 3.2e-3, 0.4e-3, 0.4e-3, 0.8e-3, 0.4e-3],
-    170: [0.2e-3, 1.25e-3, 3.2e-3, 0.4e-3, 0.4e-3, 0.8e-3, 0.4e-3],
-    250: [0.2e-3, 1.25e-3, 6.4e-3, 0.4e-3, 0.4e-3, 0.8e-3, 0.4e-3],
-    300: [0.2e-3, 1.25e-3, 12.5e-3, 0.4e-3, 0.4e-3, 0.8e-3, 0.4e-3],
-    500: [0.25e-3, 2.5e-3, 12.5e-3, 0.8e-3, 0.8e-3, 1.5e-3, 0.8e-3],
+    15: [0.05, 0.1, 0.1, 0.05, 0.13, 0.13, 0.13],
+    30: [0.05, 0.1, 0.1, 0.05, 0.13, 0.25, 0.13],
+    50: [0.1, 0.6, 0.6, 0.13, 0.13, 0.4, 0.13],
+    100: [0.1, 0.6, 1.5, 0.13, 0.13, 0.5, 0.13],
+    150: [0.2, 0.6, 3.2, 0.4, 0.4, 0.8, 0.4],
+    170: [0.2, 1.25, 3.2, 0.4, 0.4, 0.8, 0.4],
+    250: [0.2, 1.25, 6.4, 0.4, 0.4, 0.8, 0.4],
+    300: [0.2, 1.25, 12.5, 0.4, 0.4, 0.8, 0.4],
+    500: [0.25, 2.5, 12.5, 0.8, 0.8, 1.5, 0.8],
 }
 
 PER_VOLT_TABLE = [
-    0.0025e-3,
-    0.005e-3,
-    0.025e-3,
-    0.00305e-3,
-    0.00305e-3,
-    0.00305e-3,
-    0.00305e-3,
+    0.0025,
+    0.005,
+    0.025,
+    0.00305,
+    0.00305,
+    0.00305,
+    0.00305,
 ]
 
 

planar_magnetics/geometry.py

@@ -40,7 +40,7 @@ class Point:
     y: float
 
     def __str__(self):
-        return f"{self.x*1e3} {self.y*1e3}"
+        return f"{self.x} {self.y}"
 
     def __add__(self, other: Point) -> Point:
         return Point(self.x + other.x, self.y + other.y)
@@ -264,36 +264,15 @@ def to_wire(
         # first covert the polygon into a simple path of points
         points = self.to_pwl_path()
 
-        verts = [cad.Vector(1e3 * p[0], 1e3 * p[1], z) for p in points]
+        verts = [cad.Vector(p[0], p[1], z) for p in points]
 
         if closed:
             if verts[0] != verts[-1]:
                 verts.append(verts[0])
 
         return Part.makePolygon(verts)
 
-        # # convert the path into a list of line segments
-        # segments = [
-        #     Part.LineSegment(
-        #         cad.Vector(1e3 * a[0], 1e3 * a[1], z),
-        #         cad.Vector(1e3 * b[0], 1e3 * b[1], z),
-        #     )
-        #     for a, b in zip(points[:-1], points[1:])
-        # ]
-
-        # # if points[0] != points[-1]:
-        # #     segments.append(
-        # #         Part.LineSegment(
-        # #             cad.Vector(1e3 * points[-1][0], 1e3 * points[-1][1], z),
-        # #             cad.Vector(1e3 * points[0][0], 1e3 * points[0][1], z),
-        # #         )
-        # #     )
-
-        # shapes = [segment.toShape() for segment in segments]
-
-        # return Part.Wire(shapes, closed=True)
-
-    def export_to_dxf(
+    def to_dxf(
         self,
         filename: Union[str, Path],
         version: str = "R2000",