emerge 1.0.7__py3-none-any.whl → 1.1.1__py3-none-any.whl

emerge/_emerge/geo/pcb.py

@@ -25,7 +25,7 @@ from .polybased import XYPolygon
 from .operations import change_coordinate_system, unite
 from .pcb_tools.macro import parse_macro
 from .pcb_tools.calculator import PCBCalculator
-
+from ..logsettings import DEBUG_COLLECTOR
 import numpy as np
 from loguru import logger
 from typing import Literal, Callable, overload
@@ -934,12 +934,14 @@ class StripPath:
         return self.path[element_nr]
 
 class PCBLayer:
-    
+    _DEFNAME: str = 'PCBLayer'
     def __init__(self, 
                  thickness: float,
-                 material: Material):
+                 material: Material,
+                 name: str | None = None):
         self.th: float = thickness
         self.mat: Material = material
+        self.name: str = _NAME_MANAGER(name, self._DEFNAME)
         
 ############################################################
 #                     PCB DESIGN CLASS                     #
@@ -958,7 +960,8 @@ class PCB:
                  stack: list[PCBLayer] = None,
                  name: str | None = None,
                  trace_thickness: float | None = None,
-                 zs: np.ndarray | None = None
+                 zs: np.ndarray | None = None,
+                 thick_traces: bool = False,
                  ):
         """Creates a new PCB layout class instance
 
@@ -972,10 +975,13 @@ class PCB:
             stack (list[PCBLayer], optional): Optional list of PCBLayer classes for multilayer PCB with different dielectrics. Defaults to None.
             name (str | None, optional): The PCB object name. Defaults to None.
             trace_thickness (float | None, optional): The conductor trace thickness if important. Defaults to None.
+            thick_traces: (bool, optional): If traces should be given a thickness and modeled in 3D. Defaults to False
         """
 
         self.thickness: float = thickness
+        self._thick_traces: bool = thick_traces
         self._stack: list[PCBLayer] = []
+        
         if zs is not None:
             self._zs = zs
             self.thickness = np.max(zs)-np.min(zs)
@@ -1013,9 +1019,10 @@ class PCB:
             
         self.dielectric_priority: int = 11
         self.via_priority: int = 12
+        self.conductor_priority: int = 13
 
-        self.traces: list[GeoPolygon] = []
-        self.ports: list[GeoPolygon] = []
+        self.traces: list[GeoPolygon | GeoVolume] = []
+        self.ports: list[GeoPolygon | GeoVolume] = []
         self.vias: list[Via] = []
 
         self.xs: list[float] = []
@@ -1029,9 +1036,18 @@ class PCB:
         self.calc: PCBCalculator = PCBCalculator(self.thickness, self._zs, self.material, self.unit)
 
         self.name: str = _NAME_MANAGER(name, self._DEFNAME)
-        
+
+        if not self._thick_traces and self.trace_material is not PEC:
+            DEBUG_COLLECTOR.add_report('Non PEC surface materials are used without thick traces. The SurfaceImpedance boundary condition will be used that is known to not be accurate.' +
+                                       'Please set thick_traces=True in the PCB constructor to ensure accurate losses until this issue is fixed.')
+
+    ############################################################
+    #                          PROPERTIES                     #
+    ############################################################
+
     @property
     def trace(self) -> GeoPolygon:
+        ""
         tags = []
         for trace in self.traces:
             tags.extend(trace.tags)
@@ -1040,29 +1056,36 @@ class PCB:
     
     @property
     def all_objects(self) -> list[GeoPolygon]:
-        return self.traces + self.ports
-    
-
-    def z(self, layer: int) -> float:
-        """Returns the z-height of the given layer number counter from 1 (bottom) to N (top)
-
-        Args:
-            layer (int): The layer number (1 to N)
+        """Returns all objects gnerated by the PCB layer.
 
         Returns:
-            float: the z-height
+            list[GeoPolygon]: _description_
         """
-        if layer <= 0:
-            return self._zs[layer]
-        return self._zs[layer-1]
+        return self.traces + self.ports
     
     @property
     def top(self) -> float:
+        """ The top conductor later height (z-value in meters)."""
         return self._zs[-1]
     
     @property
     def bottom(self) -> float:
+        """The bottom conductor layer height (z-value in meters)
+
+        """
         return self._zs[0]
+
+
+    ############################################################
+    #                       PRIVATE FUNCTIONS                  #
+    ############################################################
+
+    def _lumped_element(self, poly: XYPolygon, function: Callable, width: float, length: float, name: str | None = 'LumpedElement') -> None:
+        geopoly = poly._finalize(self.cs, name=name)
+        geopoly._aux_data['func'] = function
+        geopoly._aux_data['width'] = width
+        geopoly._aux_data['height'] = length
+        self.lumped_elements.append(geopoly)
     
     def _get_z(self, element: RouteElement) -> float :
         """Return the z-height of a given Route Element
@@ -1077,12 +1100,70 @@ class PCB:
             if path._has(element):
                 return path.z
         raise RouteException('Requesting z-height of route element that is not contained in a path.')
+    
+    def __call__(self, path_nr: int) -> StripPath:
+        if path_nr >= len(self.paths):
+            self.paths.append(StripPath(self))
+        return self.paths[path_nr]
+    
+    def _gen_poly(self, xys: list[tuple[float, float]], z: float, name: str | None = None) -> GeoPolygon | GeoVolume:
+        """ Generates a GeoPoly out of a list of (x,y) coordinate tuples.
+        
+        
+        Args:
+            xys (list[tuple[float, float]]): A list of (x,y) coordinate tuples.
+            z (float, optional): The z-height of the polygon. Defaults to the top layer.
+            name (str, optional): The name of the polygon.
+            """
+        ptags = []
+        for x,y in xys:
+            px, py, pz = self.cs.in_global_cs(x*self.unit, y*self.unit, z*self.unit)
+            ptags.append(gmsh.model.occ.addPoint(px, py, pz))
+        
+        ltags = []
+        for t1, t2 in zip(ptags[:-1], ptags[1:]):
+            ltags.append(gmsh.model.occ.addLine(t1, t2))
+        ltags.append(gmsh.model.occ.addLine(ptags[-1], ptags[0]))
+        
+        tag_wire = gmsh.model.occ.addWire(ltags)
+        planetag = gmsh.model.occ.addPlaneSurface([tag_wire,])
+        if self._thick_traces:
+            if self.trace_thickness is None:
+                raise ValueError('Trace thickness not defined, cannot generate polygons. Make sure to define a trace thickness in the PCB() constructor.')
+            dx, dy, dz = self.cs.zax.np*self.trace_thickness
+            dimtags = gmsh.model.occ.extrude([(2,planetag),], dx, dy, dz)
+            voltags = [dt[1] for dt in dimtags if dt[0]==3]
+            poly = GeoVolume(voltags, name=name).prio_set(self.conductor_priority)
+        else:
+            poly = GeoPolygon([planetag,], name=name)
+            poly._store('thickness', self.trace_thickness)
+        return poly
+    
+
+    ############################################################
+    #                        USER FUNCTIONS                   #
+    ############################################################
+
+    def z(self, layer: int) -> float:
+        """Returns the z-height of the given layer number counter from 1 (bottom) to N (top)
+
+        Args:
+            layer (int): The layer number (1 to N)
+
+        Returns:
+            float: the z-height
+        """
+        if layer <= 0:
+            return self._zs[layer]
+        return self._zs[layer-1]
 
     def add_vias(self, *coordinates: tuple[float, float], radius: float,
                  z1: float | None = None,
                  z2: float | None = None,
                  segments: int = 6) -> None:
-        """Add a series of vias provided by a list of coordinates.
+        """Add a series of vias provided by a list of coordinates. 
+        
+        Vias will not be created yet. To generate the actual geometries use the function .generate_vias().
         
         Make sure to define the radius explicitly, otherwise the radius gets interpreted as a coordinate:
         
@@ -1118,10 +1199,7 @@ class PCB:
                     return poly
             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))
-        return self.paths[path_nr]
+    
     
     def determine_bounds(self, 
                          leftmargin: float = 0,
@@ -1173,7 +1251,7 @@ class PCB:
               height: float | None = None,
               origin: tuple[float, float] | None = None,
               alignment: Alignment = Alignment.CORNER,
-              name: str | None = None) -> GeoSurface:
+              name: str | None = None) -> GeoSurface | GeoVolume:
         """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.
 
@@ -1201,25 +1279,55 @@ class PCB:
                                                         origin[1] - height*self.unit/2, 
                                                         origin[2])
 
-        plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0), name=name) # type: ignore
-        plane._store('thickness', self.thickness)
-        plane = change_coordinate_system(plane, self.cs) # type: ignore
-        plane.set_material(self.trace_material)
+        if self._thick_traces:
+            plane = Box(width*self.unit, height*self.unit, self.trace_thickness, position=origin, name=name).set_material(self.trace_material)
+        else:
+            plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0), name=name) # type: ignore
+            plane._store('thickness', self.thickness)
+            plane = change_coordinate_system(plane, self.cs) # type: ignore
+            plane.set_material(self.trace_material)
         return plane # type: ignore
     
+    def radial_stub(self, pos: tuple[float, float], length: float, angle: float, direction: tuple[float, float], Nsections: int = 8, w0: float = 0, z: float = 0, material: Material = None, name: str = None) -> None:
+        x0, y0 = pos
+        dx, dy = direction
+        
+        rx, ry = dy, -dx
+
+        points = []
+        if w0==0:
+            points.append(pos)
+        else:
+            points.append((x0-rx*w0/2, y0-ry*w0/2))
+            points.append((x0+rx*w0/2, y0+ry*w0/2))
+        
+        angs = np.linspace(-angle/2, angle/2, Nsections)*np.pi/180
+        c0 = x0 + 1j*y0
+        vec = length*dx + 1j*length*dy
+        for a in angs:
+            p = c0 + vec*np.exp(1j*a)
+            points.append((p.real, p.imag))
+        
+        xs, ys = zip(*points)
+        self.add_poly(xs, ys, z, material, name)
+        
     def generate_pcb(self, 
                 split_z: bool = True,
-                merge: bool = True) -> GeoVolume:
+                merge: bool = True) -> list[GeoVolume] | GeoVolume:
         """Generate the PCB Block object
 
+        Args:
+            split_z (bool, optional): If a PCB consisting of a thickness, material and n_layers should be split in sub domains. Defaults to True
+            merge: (bool, optional): If an output list of multiple volumes should be merged into a single object.
+        
         Returns:
-            GeoVolume: The PCB Block
+            GeoVolume | List[GeoVolume]: The PCB Block or blocks
         """
         x0, y0, z0 = self.origin*self.unit
         
-        Nmats = len(set([layer.mat.name for layer in self._stack]))
+        n_materials = len(set([layer.mat.name for layer in self._stack]))
         
-        if split_z and self._zs.shape[0]>2 or Nmats > 1:
+        if split_z and self._zs.shape[0]>2 or n_materials > 1:
             
             boxes: list[GeoVolume] = []
             for i, (z1, z2, layer) in enumerate(zip(self._zs[:-1],self._zs[1:],self._stack)):
@@ -1228,12 +1336,12 @@ class PCB:
                           self.length*self.unit,
                           h*self.unit,
                           position=(x0, y0, z0+z1*self.unit),
-                          name=f'{self.name}_layer{i}')
+                          name=layer.name)
                 box.material = layer.mat
                 box = change_coordinate_system(box, self.cs)
                 box.prio_set(self.dielectric_priority)
                 boxes.append(box)
-            if merge and Nmats == 1:
+            if merge and n_materials == 1:
                 return GeoVolume.merged(boxes).prio_set(self.dielectric_priority) # type: ignore
             return boxes # type: ignore
         
@@ -1247,7 +1355,7 @@ class PCB:
         box = change_coordinate_system(box, self.cs)
         return box # type: ignore
 
-    def generate_air(self, height: float, name: str = 'PCBAirbox') -> GeoVolume:
+    def generate_air(self, height: float, name: str = 'PCBAirbox', bottom: bool = False) -> GeoVolume:
         """Generate the Air Block object
 
         This requires that the width, depth and origin are deterimed. This 
@@ -1256,11 +1364,16 @@ class PCB:
         Returns:
             GeoVolume: The PCB Block
         """
+        dz = 0
+        
         x0, y0, z0 = self.origin*self.unit
+        if bottom:
+            dz = z0-self.thickness*self.unit-height*self.unit
+            
         box = Box(self.width*self.unit, 
                   self.length*self.unit, 
                   height*self.unit, 
-                  position=(x0,y0,z0),
+                  position=(x0,y0,z0+dz),
                   name=name)
         box = change_coordinate_system(box, self.cs)
         return box # type: ignore
@@ -1334,16 +1447,9 @@ class PCB:
         
         return poly
 
-    def _lumped_element(self, poly: XYPolygon, function: Callable, width: float, length: float, name: str | None = 'LumpedElement') -> None:
-        geopoly = poly._finalize(self.cs, name=name)
-        geopoly._aux_data['func'] = function
-        geopoly._aux_data['width'] = width
-        geopoly._aux_data['height'] = length
-        self.lumped_elements.append(geopoly)
-
     def modal_port(self,
                   point: StripLine,
-                  height: float,
+                  height: float | tuple[float, float],
                   width_multiplier: float = 5.0,
                   width: float | None = None,
                   name: str | None = 'ModalPort'
@@ -1362,8 +1468,12 @@ class PCB:
         Returns:
             GeoSurface: The GeoSurface object that can be used for the waveguide.
         """
-        
-        height = (self.thickness + height)
+        if isinstance(height, tuple):
+            dz, height = height
+        else:
+            dz = 0
+            
+        height = (self.thickness + height + dz)
         
         if width is not None:
             W = width
@@ -1373,7 +1483,7 @@ class PCB:
         ds = point.dirright
         x0 = point.x - ds[0]*W/2
         y0 = point.y - ds[1]*W/2
-        z0 =  - self.thickness
+        z0 =  - self.thickness - dz
         ax1 = np.array([ds[0], ds[1], 0])*self.unit*W
         ax2 = np.array([0,0,1])*height*self.unit
 
@@ -1428,36 +1538,17 @@ class PCB:
         """
         if material is None:
             material = self.trace_material
-        poly = PCBPoly(xs, ys, z, material,name=name)
+        poly = PCBPoly(xs, ys, z, material, name=name)
         
         self.polies.append(poly)
-        
-
-    def _gen_poly(self, xys: list[tuple[float, float]], z: float, name: str | None = None) -> GeoPolygon:
-        """ Generates a GeoPoly out of a list of (x,y) coordinate tuples"""
-        ptags = []
-        for x,y in xys:
-            px, py, pz = self.cs.in_global_cs(x*self.unit, y*self.unit, z*self.unit)
-            ptags.append(gmsh.model.occ.addPoint(px, py, pz))
-        
-        ltags = []
-        for t1, t2 in zip(ptags[:-1], ptags[1:]):
-            ltags.append(gmsh.model.occ.addLine(t1, t2))
-        ltags.append(gmsh.model.occ.addLine(ptags[-1], ptags[0]))
-        
-        tag_wire = gmsh.model.occ.addWire(ltags)
-        planetag = gmsh.model.occ.addPlaneSurface([tag_wire,])
-        poly = GeoPolygon([planetag,], name=name)
-        poly._store('thickness', self.trace_thickness)
-        return poly
     
     @overload
-    def compile_paths(self, merge: Literal[True]) -> GeoSurface: ...
+    def compile_paths(self, merge: Literal[True]) -> GeoSurface | GeoVolume: ...
     
     @overload
-    def compile_paths(self, merge: Literal[False] = ...) -> list[GeoSurface]: ...
+    def compile_paths(self, merge: Literal[False] = ...) -> list[GeoSurface] | list[GeoVolume]: ...
 
-    def compile_paths(self, merge: bool = False) -> list[GeoPolygon] | GeoSurface:
+    def compile_paths(self, merge: bool = False) -> list[GeoPolygon] | GeoSurface | GeoVolume:
         """Compiles the striplines and returns a list of polygons or asingle one.
 
         The Z=0 argument determines the height of the striplines. Z=0 corresponds to the top of

emerge/_emerge/geo/shapes.py

@@ -160,11 +160,14 @@ class Sphere(GeoVolume):
         x,y,z = position
         self.tags: list[int] = [gmsh.model.occ.addSphere(x,y,z,radius),]
 
+        gmsh.model.occ.synchronize()
+        self._add_face_pointer('outside', tag=self.boundary().tags[0])
+        
     @property
     def outside(self) -> FaceSelection:
         """The outside boundary of the sphere.
         """
-        return self.boundary()
+        return self.face('outside')
 
 class XYPlate(GeoSurface):
     """Generates and XY-plane oriented plate
@@ -311,6 +314,7 @@ class Cylinder(GeoVolume):
                                          height*ax[0], height*ax[1], height*ax[2],
                                          radius)
             super().__init__(cyl, name=name)
+        
         self._add_face_pointer('front', cs.origin, -cs.zax.np)
         self._add_face_pointer('back', cs.origin+height*cs.zax.np, cs.zax.np)
         self._add_face_pointer('bottom', cs.origin, -cs.zax.np)
@@ -471,15 +475,16 @@ class HalfSphere(GeoVolume):
         self._add_face_pointer('bottom',np.array(position), np.array(direction))
         self._add_face_pointer('face',np.array(position), np.array(direction))
         self._add_face_pointer('disc',np.array(position), np.array(direction))
-
+        
+        gmsh.model.occ.synchronize()
+        self._add_face_pointer('outside', tag=self.boundary(exclude='disc').tags[0])
+        
     @property
     def outside(self) -> FaceSelection:
-        """The outside of the sphere excluding the flat disc face
-
-        Returns:
-            FaceSelection: _description_
+        """The outside boundary of the half sphere.
         """
-        return self.boundary(exclude=('disc',))
+        return self.face('outside')
+
     
     @property
     def disc(self) -> FaceSelection: