emerge 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

emerge/_emerge/geo/pcb.py

@@ -17,10 +17,6 @@
 
 from __future__ import annotations
 
-import numpy as np
-from scipy.optimize import root, fmin
-import gmsh
-
 from ..cs import CoordinateSystem, GCS, Axis
 from ..geometry import GeoPolygon, GeoVolume, GeoSurface
 from ..material import Material, AIR, COPPER
@@ -29,11 +25,14 @@ from .polybased import XYPolygon
 from .operations import change_coordinate_system
 from .pcb_tools.macro import parse_macro
 from .pcb_tools.calculator import PCBCalculator
+
+import numpy as np
 from loguru import logger
-from typing import Literal, Callable
+from typing import Literal, Callable, overload
 from dataclasses import dataclass
-import math
 
+import math
+import gmsh
 
 ############################################################
 #                        EXCEPTIONS                        #
@@ -64,7 +63,15 @@ def normalize(vector: np.ndarray) -> np.ndarray:
         return vector
     return vector / norm
 
-def _rot_mat(angle):
+def _rot_mat(angle: float) -> np.ndarray:
+    """Returns a 2D rotation matrix given an angle in degrees
+
+    Args:
+        angle (float): The angle in degrees
+
+    Returns:
+        np.ndarray: The rotation matrix
+    """
     ang = -angle * np.pi/180
     return np.array([[np.cos(ang), -np.sin(ang)], [np.sin(ang), np.cos(ang)]])
 
@@ -107,6 +114,10 @@ class RouteElement:
         self.direction: np.ndarray = None
         self.dirright: np.ndarray = None
     
+    @property
+    def xy(self) -> tuple[float, float]:
+        return self.x, self.y
+
     @property
     def nr(self) -> tuple[float,float]:
         return (self.x + self.dirright[0]*self.width/2, self.y + self.dirright[1]*self.width/2)
@@ -117,11 +128,11 @@ class RouteElement:
     
     @property
     def right(self) -> list[tuple[float, float]]:
-        pass
+        raise NotImplementedError()
 
     @property
     def left(self) -> list[tuple[float, float]]:
-        pass
+        raise NotImplementedError()
     
     def __eq__(self, other: RouteElement) -> bool:
         return approx(self.x, other.x) and approx(self.y, other.y) and (1-abs(np.sum(self.direction*other.direction)))<1e-8
@@ -158,7 +169,7 @@ class StripTurn(RouteElement):
                  direction: tuple[float, float],
                  angle: float,
                  corner_type: str = 'round',
-                 champher_distance: float = None):
+                 champher_distance: float | None = None):
         self.xold: float = x
         self.yold: float = y
         self.width: float = width
@@ -221,7 +232,8 @@ class StripTurn(RouteElement):
             y2 = yend - dist * self.direction[1]
 
             return [(x1, y1), (x2, y2), (xend, yend)]
-    
+        else:
+            raise RouteException(f'Trying to route a StripTurn with an unknown corner type: {self.corner_type}')
     @property
     def left(self) -> list[tuple[float, float]]:
         if self.angle < 0:
@@ -258,7 +270,69 @@ class StripTurn(RouteElement):
             y2 = yend - dist * self.direction[1]
 
             return [(xend, yend), (x2, y2), (x1, y1)]
+        else:
+            raise RouteException(f'Trying to route a StripTurn with an unknown corner type: {self.corner_type}')
  
+class StripCurve(StripTurn):
+    def __init__(self,
+                 x: float,
+                 y: float,
+                 width: float,
+                 direction: tuple[float, float],
+                 angle: float,
+                 radius: float,
+                 dang: float = 10.0):
+        self.xold: float = x
+        self.yold: float = y
+        self.width: float = width
+        self.old_direction: np.ndarray = normalize(np.array(direction))
+        self.direction: np.ndarray = _rot_mat(angle) @ self.old_direction
+        self.angle: float = angle
+        self.radius: float = radius
+        self.dirright: np.ndarray = np.array([self.old_direction[1], -self.old_direction[0]])
+        self.dang: float = dang
+
+        angd = abs(angle*np.pi/180)
+        self.start = np.array([x,y])
+        self.circ_origin = self.start + radius * np.sign(angle) * self.dirright
+
+        self._xhat = -self.dirright * np.sign(angle)
+        self._yhat = self.old_direction
+        
+        self.end = self.circ_origin + radius*(self._xhat*np.cos(angd)+self._yhat*np.sin(angd))
+        self.x, self.y = self.end
+
+    def __str__(self) -> str:
+        return f'StripCurve[{self.x},{self.y},w={self.width},d=({self.direction})]'
+
+    @property
+    def right(self) -> list[tuple[float, float]]:
+        points: list[tuple[float, float]] = []
+        Npts = int(np.ceil(abs(self.angle/self.dang)))
+        R = self.radius-np.sign(self.angle)*self.width/2
+        print(R, self.circ_origin, self._xhat, self._yhat)
+        for i in range(Npts):
+            ang = abs((i+1)/Npts * self.angle * np.pi/180)
+            pnew = self.circ_origin + R*(self._xhat*np.cos(ang)+self._yhat*np.sin(ang))
+            points.append((pnew[0], pnew[1]))
+        
+        return points
+
+    @property
+    def left(self) -> list[tuple[float, float]]:
+        points: list[tuple[float, float]] = []
+
+        Npts = int(np.ceil(abs(self.angle/self.dang)))
+        R = self.radius+np.sign(self.angle)*self.width/2
+        print(R, self.circ_origin, self._xhat, self._yhat)
+        for i in range(Npts):
+            ang = abs((i+1)/Npts * self.angle * np.pi/180)
+            pnew = self.circ_origin + R*(self._xhat*np.cos(ang)+self._yhat*np.sin(ang))
+            points.append((pnew[0], pnew[1]))
+        
+        return points[::-1]
+
+    
 ############################################################
 #                    THE STRIP PATH CLASS                  #
 ############################################################
@@ -316,7 +390,7 @@ class StripPath:
         return self
     
     def straight(self, distance: 
-                 float, width: float = None, 
+                 float, width: float | None = None, 
                  dx: float = 0, 
                  dy: float = 0) -> StripPath:
         """Add A straight section to the stripline.
@@ -381,7 +455,7 @@ class StripPath:
         return self
     
     def turn(self, angle: float, 
-             width: float = None, 
+             width: float | None = None, 
              corner_type: Literal['champher','square'] = 'champher') -> StripPath:
         """Adds a turn to the strip path.
 
@@ -399,7 +473,9 @@ class StripPath:
         """
         x, y = self.end.x, self.end.y
         dx, dy = self.end.direction
-        
+        if abs(angle) <= 20:
+            corner_type = 'square'
+            logger.warning('Small turn detected, defaulting to rectangular corners because chamfers would add to much detail.')
         if width is not None:
             if width != self.end.width:
                 self._add_element(StripLine(x, y, width, (dx, dy)))
@@ -407,6 +483,37 @@ class StripPath:
             width=self.end.width
         self._add_element(StripTurn(x, y, width, (dx, dy), angle, corner_type))
         return self
+
+    def curve(self, angle: float, radius: float,
+             width: float | None = None, 
+             corner_type: Literal['champher','square'] = 'champher',
+             dang: float = 10) -> StripPath:
+        """Adds a bend to the strip path.
+
+        The angle is specified in degrees. The width of the turn will be the same as the last segment.
+        optionally, a different width may be provided. 
+        By default, all corners will be cut using the "champher" type. Other options are not yet provided.
+
+        Args:
+            angle (float): The turning angle
+            width (float, optional): The stripline width. Defaults to None.
+            corner_type (str, optional): The corner type. Defaults to 'champher'.
+
+        Returns:
+            StripPath: The current StripPath object
+        """
+        if angle == 0:
+            logger.trace('Zero angle turn, passing action')
+            return self
+        x, y = self.end.x, self.end.y
+        dx, dy = self.end.direction
+        if width is not None:
+            if width != self.end.width:
+                self._add_element(StripLine(x, y, width, (dx, dy)))
+        else:
+            width=self.end.width
+        self._add_element(StripCurve(x, y, width, (dx, dy), angle, radius, dang=dang))
+        return self
     
     def store(self, name: str) -> StripPath:
         """ Store the current x,y coordinate labeled in the PCB object.
@@ -419,13 +526,12 @@ class StripPath:
         Returns:
             StripPath: The current StripPath object.
         """
-        self.pcb.store(name, self.end.x, self.end.y)
         self.pcb.stored_striplines[name] = self.end
         return self
     
     def split(self, 
-              direction: tuple[float, float] = None,
-              width: float = None) -> StripPath:
+              direction: tuple[float, float]  | None= None,
+              width: float  | None= None) -> StripPath:
         """Split the current path in N new paths given by a new departure direction
 
         Args:
@@ -490,7 +596,6 @@ class StripPath:
         self.pcb._lumped_element(poly, impedance_function, width, length)
         return self.pcb.new(x+dx*length, y+dy*length, self.end.width, self.end.direction, self.z)
 
-
     def cut(self) -> StripPath:
         """Split the current path in N new paths given by a new departure direction
 
@@ -529,9 +634,9 @@ class StripPath:
             znew: float,
             radius: float,
             proceed: bool = True,
-            direction: tuple[float, float] = None,
-            width: float = None,
-            extra: float = None,
+            direction: tuple[float, float] | None = None,
+            width: float | None = None,
+            extra: float | None = None,
             segments: int = 6) -> StripPath:
         """Adds a via to the circuit
 
@@ -576,13 +681,13 @@ class StripPath:
         return self
 
     def jump(self, 
-             dx: float = None,
-             dy: float = None,
-             width: float = None,
-             direction: tuple[float, float] = None,
-             gap: float = None,
-             side: Literal['left','right'] = None,
-             reverse: float = None) -> StripPath:
+             dx: float | None = None,
+             dy: float | None = None,
+             width: float | None = None,
+             direction: tuple[float, float] | None = None,
+             gap: float | None = None,
+             side: Literal['left','right'] | None = None,
+             reverse: float | None = None) -> StripPath:
         """Add an unconnected jump to the currenet stripline.
 
         The last stripline path will be terminated and a new one will be started based on the 
@@ -630,9 +735,9 @@ class StripPath:
         return self.pcb.new(x, y, width, direction)
     
     def to(self, dest: tuple[float, float], 
-           arrival_dir: tuple[float, float] = None,
-           arrival_margin: float = None,
-           angle_step: float = 90):
+           arrival_dir: tuple[float, float] | None = None,
+           arrival_margin: float  | None= None,
+           angle_step: float = 90) -> StripPath:
         """
         Extend the path from current end point to dest (x, y).
         Optionally ensure arrival in arrival_dir after a straight segment of arrival_margin.
@@ -672,7 +777,7 @@ class StripPath:
         dt = max_t / 1000.0  # resolution of search
         found = False
         desired_q = None
-        cand_dx = cand_dy = 0.0
+        #cand_dx = cand_dy = 0.0
         
         while t <= max_t:
             # candidate intercept point
@@ -700,8 +805,8 @@ class StripPath:
             raise RuntimeError("Could not find an intercept angle matching quantization")
 
         # 1) Perform initial quantized turn
-        if abs(desired_q) > atol:
-            self.turn(-desired_q)
+        if abs(desired_q) > atol: # type: ignore
+            self.turn(-desired_q) # type: ignore
         x0 = self.end.x
         y0 = self.end.y
         # compute new heading vector after turn
@@ -738,9 +843,8 @@ class StripPath:
         back_ang = math.degrees(math.atan2(cross2, dot2))
         
         backoff = math.tan(abs(back_ang)*np.pi/360)*self.end.width/2
-        self.straight(s - backoff)
-        
 
+        self.straight(s - backoff)
         self.turn(-back_ang)
 
         x0 = self.end.x
@@ -748,11 +852,10 @@ class StripPath:
         D = math.hypot(tx-x0, ty-y0)
         # 4) Final straight into destination by arrival_margin + t
         self.straight(D)
-        
 
         return self
 
-    def macro(self, path: str, width: float = None, start_dir: tuple[float, float] = None) -> StripPath:
+    def macro(self, path: str, width: float | None = None, start_dir: tuple[float, float] | None = None) -> StripPath:
         r"""Parse an EMerge macro command string
 
         The start direction by default is the abslute current heading. If a specified heading is provided
@@ -796,14 +899,14 @@ class StripPath:
         return self.path[element_nr]
 
 ############################################################
-#                     PCB DESIGN CLASS                    #
+#                     PCB DESIGN CLASS                     #
 ############################################################
 
 class PCB:
     def __init__(self,
                  thickness: float,
                  unit: float = 0.001,
-                 cs: CoordinateSystem = None,
+                 cs: CoordinateSystem | None = None,
                  material: Material = AIR,
                  layers: int = 2,
                  ):
@@ -811,16 +914,16 @@ class PCB:
         self.thickness: float = thickness
         self._zs: np.ndarray = np.linspace(-self.thickness, 0, layers)
         self.material: Material = material
-        self.width: float = None
-        self.length: float = None
-        self.origin: np.ndarray = None
+        self.width: float | None = None
+        self.length: float | None = None
+        self.origin: np.ndarray = np.array([0.,0.,0.])
         self.paths: list[StripPath] = []
         self.polies: list[PCBPoly] = []
 
         self.lumped_ports: list[StripLine] = []
         self.lumped_elements: list[GeoPolygon] = []
 
-        self.unit = unit
+        self.unit: float = unit
 
         self.cs: CoordinateSystem = cs
         if self.cs is None:
@@ -864,7 +967,7 @@ class PCB:
         """
         return self._zs[layer-1]
     
-    def _get_z(self, element: RouteElement) -> float:
+    def _get_z(self, element: RouteElement) -> float :
         """Return the z-height of a given Route Element
 
         Args:
@@ -876,38 +979,23 @@ class PCB:
         for path in self.paths:
             if path._has(element):
                 return path.z
-        return None
+        raise RouteException('Requesting z-height of route element that is not contained in a path.')
 
-    def store(self, name: str, x: float, y:float):
-        """Store the x,y coordinate pair one label provided by name
-
-        Args:
-            name (str): The corodinate label name
-            x (float): The x-coordinate
-            y (float): The y-coordinate
-        """
-        self.stored_coords[name] = (x,y)
-
-    def load(self, name: str) -> tuple[float, float] | StripLine:
+    def load(self, name: str) -> StripLine:
         """Acquire the x,y, coordinate associated with the label name.
         
         Args:
             name (str): The name of the x,y coordinate
             
         """
-        if name in self.stored_striplines and name in self.stored_coords:
-            logger.warning(f'There is both a coordinate and stripline under the name {name}.')
-            return self.stored_striplines[name]
-        elif name in self.stored_striplines:
+        if name in self.stored_striplines:
             return self.stored_striplines[name]
-        elif name in self.stored_coords:
-            return self.stored_coords[name]
         else:
             raise ValueError(f'There is no stripline or coordinate under the name of {name}')
     
     def __call__(self, path_nr: int) -> StripPath:
         if path_nr >= len(self.paths):
-            self.paths.append(StripPath())
+            self.paths.append(StripPath(self))
         return self.paths[path_nr]
     
     def determine_bounds(self, 
@@ -956,9 +1044,9 @@ class PCB:
 
     def plane(self,
               z: float,
-              width: float = None,
-              height: float = None,
-              origin: tuple[float, float] = None,
+              width: float | None = None,
+              height: float | None = None,
+              origin: tuple[float, float] | None = None,
               alignment: Literal['corner','center'] = 'corner') -> GeoSurface:
         """Generates a generic rectangular plate in the XY grid.
         If no size is provided, it defaults to the entire PCB size assuming that the bounds are determined.
@@ -974,17 +1062,22 @@ class PCB:
             GeoSurface: _description_
         """
         if width is None or height is None or origin is None:
+            if self.width is None or self.length is None or self.origin:
+                raise RouteException('Cannot define a plane with no possible definition of its size.')
             width = self.width
             height = self.length
             origin = (self.origin[0]*self.unit, self.origin[1]*self.unit)
-        origin = origin + (z*self.unit, )
+        
+        origin: tuple[float, ...] = origin + (z*self.unit, ) # type: ignore
 
         if alignment == 'center':
-            origin = (origin[0] - width*self.unit/2, origin[1]-height*self.unit/2, origin[2])
+            origin = (origin[0] - width*self.unit/2, 
+                                                        origin[1] - height*self.unit/2, 
+                                                        origin[2])
 
-        plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0))
-        plane = change_coordinate_system(plane, self.cs)
-        return plane
+        plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0)) # type: ignore
+        plane = change_coordinate_system(plane, self.cs) # type: ignore
+        return plane # type: ignore
     
     def gen_pcb(self, 
                 split_z: bool = True,
@@ -1004,7 +1097,7 @@ class PCB:
                 if (z-zvalues_isolated[-1]) <= layer_tolerance:
                     continue
                 zvalues_isolated.append(z)
-            boxes = []
+            boxes: list[GeoVolume] = []
             for z1, z2 in zip(zvalues_isolated[:-1],zvalues_isolated[1:]):
                 h = z2-z1
                 box = Box(self.width*self.unit,
@@ -1015,8 +1108,8 @@ class PCB:
                 box = change_coordinate_system(box, self.cs)
                 boxes.append(box)
             if merge:
-                return GeoVolume.merged(boxes)
-            return boxes
+                return GeoVolume.merged(boxes) # type: ignore
+            return boxes # type: ignore
         
         box = Box(self.width*self.unit, 
                   self.length*self.unit, 
@@ -1024,7 +1117,7 @@ class PCB:
                   position=(x0,y0,z0-self.thickness*self.unit))
         box.material = self.material
         box = change_coordinate_system(box, self.cs)
-        return box
+        return box # type: ignore
 
     def gen_air(self, height: float) -> GeoVolume:
         """Generate the Air Block object
@@ -1041,7 +1134,7 @@ class PCB:
                   height*self.unit, 
                   position=(x0,y0,z0))
         box = change_coordinate_system(box, self.cs)
-        return box
+        return box # type: ignore
 
     def new(self, 
             x: float, 
@@ -1072,7 +1165,7 @@ class PCB:
         self.paths.append(path)  
         return path
     
-    def lumped_port(self, stripline: StripLine, z_ground: float = None) -> GeoPolygon:
+    def lumped_port(self, stripline: StripLine, z_ground: float | None = None) -> GeoPolygon:
         """Generate a lumped-port object to be created.
 
         Args:
@@ -1152,7 +1245,7 @@ class PCB:
 
         plate = Plate(np.array([x0,y0,z0])*self.unit, ax1, ax2)
         plate = change_coordinate_system(plate, self.cs)
-        return plate
+        return plate # type: ignore
 
     def generate_vias(self, merge=False) -> list[Cyllinder] | Cyllinder:
         """Generates the via objects.
@@ -1175,14 +1268,14 @@ class PCB:
             vias.append(cyl)
         if merge:
             
-            return GeoVolume.merged(vias)
+            return GeoVolume.merged(vias) # type: ignore
         return vias   
 
     def add_poly(self, 
                  xs: list[float],
                  ys: list[float],
                  z: float = 0,
-                 material: Material = COPPER):
+                 material: Material = COPPER) -> None:
         """Add a custom polygon to the PCB
 
         Args:
@@ -1210,6 +1303,12 @@ class PCB:
         poly = GeoPolygon([planetag,])
         return poly
     
+    @overload
+    def compile_paths(self, merge: Literal[True]) -> GeoSurface: ...
+    
+    @overload
+    def compile_paths(self, merge: Literal[False] = ...) -> list[GeoSurface]: ...
+
     def compile_paths(self, merge: bool = False) -> list[GeoPolygon] | GeoSurface:
         """Compiles the striplines and returns a list of polygons or asingle one.
 
@@ -1269,7 +1368,6 @@ class PCB:
             polys.material = COPPER
         return polys
                 
-
 ############################################################
 #                        DEPRICATED                       #
 ############################################################

emerge/_emerge/geo/pcb_tools/calculator.py

@@ -1,9 +1,9 @@
 import numpy as np
 from ...material import Material
+from ...const import Z0 as n0
 
 PI = np.pi
 TAU = 2*PI
-n0 = 376.73
 
 def microstrip_z0(W: float, th: float, er: float):
     u = W/th
@@ -14,7 +14,7 @@ def microstrip_z0(W: float, th: float, er: float):
 
 class PCBCalculator:
 
-    def __init__(self, thickness: float, layers: np.array, material: Material, unit: float):
+    def __init__(self, thickness: float, layers: np.ndarray, material: Material, unit: float):
         self.th = thickness
         self.layers = layers
         self.mat = material

emerge/_emerge/geo/pcb_tools/macro.py

@@ -25,8 +25,8 @@ def rotation_angle(a: tuple[float, float], b: tuple[float, float]) -> float:
 @dataclass
 class Instruction:
     instr: str
-    args: tuple[int]
-    kwargs: dict[str,float] = None
+    args: tuple[int | float, ...]
+    kwargs: dict[str,float] | None = None
 
     def __post_init__(self):
         if self.kwargs is None:
@@ -37,33 +37,34 @@ char_class = ''.join(re.escape(c) for c in symbols)
 
 pattern = re.compile(rf'([{char_class}])([\d\,\.\-]+)')
 
-def parse_macro(pathstring: str, width: int, direction: tuple[float, float]) -> list[Instruction]:
+def parse_macro(pathstring: str, width: int | float, direction: tuple[float, float]) -> list[Instruction]:
     instructions = pattern.findall(pathstring.replace(' ',''))
     
     oi = []
     for com, val in instructions:
         if ',' in val:
-            ival, width = [float(x) for x in val.split(',')]
+            val_list: list[float] = [float(x) for x in val.split(',')]
+            ival, width = val_list[0], val_list[1]
         else:
             ival = float(val)
         if com == '=':
-            oi.append(Instruction('straight',(ival,),{'width': width}))
+            oi.append(Instruction('straight',(ival,),{'width': width})) #type: ignore
         elif com == '>':
-            oi.append(Instruction('turn',(rotation_angle(direction,(1,0)),) ))
+            oi.append(Instruction('turn',(rotation_angle(direction, (1., 0.)),) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))
-            direction = (1,0)
+            direction = (1. ,0. )
         elif com == '<':
-            oi.append(Instruction('turn',(rotation_angle(direction,(-1,0)),) ))
+            oi.append(Instruction('turn',(rotation_angle(direction, (-1., 0.)),) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))
-            direction = (-1,0)
+            direction = (-1.,0.)
         elif com == 'v':
-            oi.append(Instruction('turn',(rotation_angle(direction,(0,-1)),) ))
+            oi.append(Instruction('turn',(rotation_angle(direction, (0.,-1.)),) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))
-            direction = (0,-1)
+            direction = (0.,-1.)
         elif com == '^':
-            oi.append(Instruction('turn',(rotation_angle(direction,(0,1)),) ))
+            oi.append(Instruction('turn',(rotation_angle(direction, (0.,1.)),) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))
-            direction = (0,1)
+            direction = (0.,1.)
         elif com == '\\':
             oi.append(Instruction('turn',(90,) ))
             oi.append(Instruction('straight',(ival,),{'width': width}))

emerge/_emerge/geo/pmlbox.py

@@ -106,7 +106,7 @@ def _add_pml_layer(center: tuple[float, float, float],
             plate = Plate(np.array([p0x-tW/2, p0y-tD/2, p0z-dz*thickness/2 + dz*(n+1)*thl]), ax1, ax2)
             planes.append(plate)
     
-    pml_box.material = Material(_neff=np.sqrt(material.er*material.ur), _fer=ermat, _fur=urmat)
+    pml_box.material = Material(_neff=np.sqrt(material.er*material.ur), _fer=ermat, _fur=urmat, color='#bbbbff', opacity=0.1)
     pml_box.max_meshsize = thickness/N_mesh_layers
     pml_box._embeddings = planes