emerge 0.6.11__py3-none-any.whl → 1.0.1__py3-none-any.whl

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.11"
+__version__ = "1.0.1"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -27,7 +27,7 @@ __version__ = "0.6.11"
 NTHREADS = "1"
 os.environ["EMERGE_STD_LOGLEVEL"] = os.getenv("EMERGE_STD_LOGLEVEL", default="INFO")
 os.environ["EMERGE_FILE_LOGLEVEL"] = os.getenv("EMERGE_FILE_LOGLEVEL", default="DEBUG")
-os.environ["OMP_NUM_THREADS"] = os.getenv("OMP_NUM_THREADS", default="4")
+os.environ["OMP_NUM_THREADS"] = os.getenv("OMP_NUM_THREADS", default="1")
 os.environ["MKL_NUM_THREADS"] = os.getenv("MKL_NUM_THREADS", default="4")
 os.environ["OPENBLAS_NUM_THREADS"] = NTHREADS
 os.environ["VECLIB_MAXIMUM_THREADS"] = NTHREADS

emerge/_emerge/bc.py

@@ -83,7 +83,7 @@ class BoundaryCondition:
             raise ValueError(f'All tags must have the same dimension, instead its {tags}')
         dimension = tags[0][0]
         if self.dimension is BCDimension.ANY:
-            logger.info(f'Assigning dimension {BCDimension(dimension)} to {self}')
+            logger.info(f'Assigning {self} to dimension{BCDimension(dimension)}')
             self.dimension = BCDimension(dimension)
         elif self.dimension != BCDimension(dimension):
             raise ValueError(f'Current boundary condition has dimension {self.dimension}, but tags have dimension {BCDimension(dimension)}')
@@ -131,6 +131,13 @@ class BoundaryConditionSet:
         self.boundary_conditions: list[BoundaryCondition] = []
         self._initialized: bool = False
     
+    def cleanup(self) -> None:
+        """ Removes non assigned boundary conditions"""
+        logger.trace("Cleaning up boundary conditions.")
+        toremove = [bc for bc in self.boundary_conditions if len(bc.tags)==0]
+        logger.trace(f"Removing: {toremove}")
+        self.boundary_conditions = [bc for bc in self.boundary_conditions if len(bc.tags)>0]
+        
     def _construct_bc(self, constructor: type) -> type:
         def constr(*args, **kwargs):
             obj = constructor(*args, **kwargs)
@@ -201,8 +208,6 @@ class BoundaryConditionSet:
 
         bc.add_tags(bc.selection.dimtags)
 
-        logger.info('Excluding other possible boundary conditions')
-
         for existing_bc in self.boundary_conditions:
             excluded = existing_bc.exclude_bc(bc)
             if excluded:

emerge/_emerge/cacherun.py

@@ -0,0 +1,79 @@
+# inside your module, e.g. utils.py
+import os
+import sys
+
+import ast
+import textwrap
+from pathlib import Path
+
+
+def _is_plain_check_run(test: ast.AST) -> bool:
+    """True only for a bare call to check_run() as the entire if-test."""
+    if not isinstance(test, ast.Call) or test.args or test.keywords:
+        return False
+    f = test.func
+    return (
+        isinstance(f, ast.Attribute) and f.attr == "cache_run"
+    ) or (
+        isinstance(f, ast.Name) and f.id == "cache_run"
+    )
+
+def get_run_block_str(source: str) -> str:
+    """
+    Return all source text before the first `if check_run():` / `if *.check_run():`.
+    Returns None if no matching if-statement exists.
+    """
+    tree = ast.parse(source)
+    candidates = [n for n in ast.walk(tree) if isinstance(n, ast.If) and _is_plain_check_run(n.test)]
+    if not candidates:
+        return None
+    first = min(candidates, key=lambda n: n.lineno)
+    lines = source.splitlines(keepends=True)
+    return "".join(lines[: first.lineno - 1])
+
+
+def get_build_block_str(source: str) -> str | None:
+    """Return the code string inside the first `if *.checkrun(...):` block, or None."""
+    tree = ast.parse(source)
+    for node in ast.walk(tree):
+        if isinstance(node, ast.If) and isinstance(node.test, ast.Call):
+            f = node.test.func
+            called = (isinstance(f, ast.Attribute) and f.attr == "cache_build") or \
+                     (isinstance(f, ast.Name) and f.id == "cache_build")
+            if called and node.body:
+                start = node.body[0].lineno - 1           # 0-based start line
+                end = node.body[-1].end_lineno            # 1-based end line (inclusive)
+                lines = source.splitlines()
+                block = "\n".join(lines[start:end])
+                return textwrap.dedent(block)
+    return None
+
+def entry_script_path():
+    main = sys.modules.get("__main__")
+    # Most normal runs: python path/to/app.py
+    if main and hasattr(main, "__file__"):
+        return os.path.abspath(main.__file__)
+    # Fallbacks (e.g. python -m pkg.mod)
+    if sys.argv and sys.argv[0] not in ("", "-c"):
+        return os.path.abspath(sys.argv[0])
+    # Interactive sessions, notebooks, or embedded interpreters
+    return None
+
+
+def get_build_section() -> str:
+    """ Returns the string section inside the check_build() if statement"""
+    name = entry_script_path()
+
+    lines = get_build_block_str(Path(name).read_text())
+    return lines
+
+def get_run_section() -> str:
+    """Return sthe string section before the check_run() if statement
+
+    Returns:
+        str: _description_
+    """
+    name = entry_script_path()
+
+    lines = get_run_block_str(Path(name).read_text())
+    return lines

emerge/_emerge/geo/__init__.py

@@ -15,7 +15,7 @@
 # along with this program; if not, see
 # <https://www.gnu.org/licenses/>.
 
-from .pcb import PCB
+from .pcb import PCB, PCBLayer
 from .pmlbox import pmlbox
 from .horn import Horn
 from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment, Cone

emerge/_emerge/geo/pcb.py

@@ -19,8 +19,8 @@ from __future__ import annotations
 
 from ..cs import CoordinateSystem, GCS, Axis
 from ..geometry import GeoPolygon, GeoVolume, GeoSurface
-from ..material import Material, AIR, COPPER
-from .shapes import Box, Plate, Cylinder
+from ..material import Material, AIR, COPPER, PEC
+from .shapes import Box, Plate, Cylinder, Alignment
 from .polybased import XYPolygon
 from .operations import change_coordinate_system, unite
 from .pcb_tools.macro import parse_macro
@@ -49,6 +49,26 @@ SIZE_NAMES = Literal['0402','0603','1005','1608','2012','3216','3225','4532','50
 _SMD_SIZE_DICT = {x: (float(x[:2])*0.05, float(x[2:])*0.1) for x in ['0402','0603','1005','1608','2012','3216','3225','4532','5025','6332']}
 
 
+class _PCB_NAME_MANAGER:
+    
+    def __init__(self):
+        self.names: set[str] = set()
+        
+    def __call__(self, name: str | None, classname: str | None = None) -> str:
+        if name is None:
+            return self(classname)
+        
+        if name not in self.names:
+            self.names.add(name)
+            return name
+        for i in range(1_000_000):
+            newname = f'{name}_{i}'
+            if newname not in self.names:
+                self.names.add(newname)
+                return newname
+                
+    
+_NAME_MANAGER = _PCB_NAME_MANAGER()
 ############################################################
 #                         FUNCTIONS                        #
 ############################################################
@@ -80,21 +100,6 @@ def _rot_mat(angle: float) -> np.ndarray:
 ############################################################
 
 
-class PCBPoly:
-
-    def __init__(self, 
-                 xs: list[float],
-                 ys: list[float],
-                 z: float = 0,
-                 material: Material = COPPER):
-        self.xs: list[float] = xs
-        self.ys: list[float] = ys
-        self.z: float = z
-        self.material: Material = material
-
-    @property
-    def xys(self) -> list[tuple[float, float]]:
-        return list([(x,y) for x,y in zip(self.xs, self.ys)])
 
 @dataclass
 class Via:
@@ -106,7 +111,7 @@ class Via:
     segments: int
 
 class RouteElement:
-
+    _DEFNAME: str = 'RouteElement'
     def __init__(self):
         self.width: float = None
         self.x: float = None
@@ -138,7 +143,7 @@ class RouteElement:
         return approx(self.x, other.x) and approx(self.y, other.y) and (1-abs(np.sum(self.direction*other.direction)))<1e-8
     
 class StripLine(RouteElement):
-
+    _DEFNAME: str = 'StripLine'
     def __init__(self,
                  x: float,
                  y: float,
@@ -161,7 +166,7 @@ class StripLine(RouteElement):
         return [(self.x - self.width/2 * self.dirright[0], self.y - self.width/2 * self.dirright[1])]
       
 class StripTurn(RouteElement):
-
+    _DEFNAME: str = 'StripTurn'
     def __init__(self,
                  x: float,
                  y: float,
@@ -234,6 +239,7 @@ class StripTurn(RouteElement):
             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:
@@ -330,17 +336,48 @@ class StripCurve(StripTurn):
         
         return points[::-1]
 
+class PCBPoly:
+    _DEFNAME: str = 'Poly'
     
+    def __init__(self, 
+                 xs: list[float],
+                 ys: list[float],
+                 z: float = 0,
+                 material: Material = PEC,
+                 name: str | None = None):
+        self.xs: list[float] = xs
+        self.ys: list[float] = ys
+        self.z: float = z
+        self.material: Material = material
+        self.name: str = _NAME_MANAGER(name, self._DEFNAME)
+        
+    @property
+    def xys(self) -> list[tuple[float, float]]:
+        return list([(x,y) for x,y in zip(self.xs, self.ys)])
+    
+    def segment(self, index: int) -> StripLine:
+        N = len(self.xs)
+        x1 = self.xs[index%N]
+        x2 = self.xs[(index+1)%N]
+        y1 = self.ys[index%N]
+        y2 = self.ys[(index+1)%N]
+        z = self.z
+        W = ((x2-x1)**2 + (y2-y1)**2)**(0.5)
+        wdir = ((y2-y1)/W, -(x2-x1)/W)
+        
+        return StripLine((x2+x1)/2, (y1+y2)/2, W, wdir)
 ############################################################
 #                    THE STRIP PATH CLASS                  #
 ############################################################
 
 class StripPath:
-
-    def __init__(self, pcb: PCB):
+    _DEFNAME: str = 'Path'
+    
+    def __init__(self, pcb: PCB, name: str | None = None):
         self.pcb: PCB = pcb
         self.path: list[RouteElement] = []
         self.z: float = 0
+        self.name: str = _NAME_MANAGER(name, self._DEFNAME)
 
     def _has(self, element: RouteElement) -> bool:
         if element in self.path:
@@ -896,36 +933,82 @@ class StripPath:
             self.path.append(RouteElement())
         return self.path[element_nr]
 
+class PCBLayer:
+    
+    def __init__(self, 
+                 thickness: float,
+                 material: Material):
+        self.th: float = thickness
+        self.mat: Material = material
+        
 ############################################################
 #                     PCB DESIGN CLASS                     #
 ############################################################
 
 class PCB:
+    _DEFNAME: str = 'PCB'
+    
     def __init__(self,
                  thickness: float,
                  unit: float = 0.001,
                  cs: CoordinateSystem | None = None,
                  material: Material = AIR,
+                 trace_material: Material = PEC,
                  layers: int = 2,
+                 stack: list[PCBLayer] = None,
+                 name: str | None = None,
+                 trace_thickness: float | None = None,
                  ):
+        """Creates a new PCB layout class instance
+
+        Args:
+            thickness (float): The total PCB thickness
+            unit (float, optional): The units used for all dimensions. Defaults to 0.001 (mm).
+            cs (CoordinateSystem | None, optional): The coordinate system to place the PCB in (XY). Defaults to None.
+            material (Material, optional): The dielectric material. Defaults to AIR.
+            trace_material (Material, optional): The trace material. Defaults to PEC.
+            layers (int, optional): The number of copper layers. Defaults to 2.
+            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.
+        """
 
         self.thickness: float = thickness
-        self._zs: np.ndarray = np.linspace(-self.thickness, 0, layers)
+        self._stack: list[PCBLayer] = []
+        
+        if stack is not None:
+            self._stack = stack
+            ths = [ly.th for ly in stack]
+            zbot = -sum(ths)
+            self._zs = np.concatenate([np.array([zbot,]), zbot + np.cumsum(np.array(ths))])
+            self.thickness = sum(ths)
+        else:
+            self._zs: np.ndarray = np.linspace(-self.thickness, 0, layers)
+            ths = np.diff(self._zs)
+            self._stack = [PCBLayer(th, material) for th in ths]
+            
+            
         self.material: Material = material
+        self.trace_material: Material = trace_material
         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.trace_thickness: float | None = trace_thickness
 
         self.unit: float = unit
 
         self.cs: CoordinateSystem = cs
         if self.cs is None:
             self.cs = GCS
+            
+        self.dielectric_priority: int = 11
+        self.via_priority: int = 12
 
         self.traces: list[GeoPolygon] = []
         self.ports: list[GeoPolygon] = []
@@ -941,6 +1024,8 @@ class PCB:
 
         self.calc: PCBCalculator = PCBCalculator(self.thickness, self._zs, self.material, self.unit)
 
+        self.name: str = _NAME_MANAGER(name, self._DEFNAME)
+        
     @property
     def trace(self) -> GeoPolygon:
         tags = []
@@ -1024,6 +1109,9 @@ class PCB:
         if name in self.stored_striplines:
             return self.stored_striplines[name]
         else:
+            for poly in self.polies:
+                if poly.name==name:
+                    return poly
             raise ValueError(f'There is no stripline or coordinate under the name of {name}')
     
     def __call__(self, path_nr: int) -> StripPath:
@@ -1080,7 +1168,8 @@ class PCB:
               width: float | None = None,
               height: float | None = None,
               origin: tuple[float, float] | None = None,
-              alignment: Literal['corner','center'] = 'corner') -> GeoSurface:
+              alignment: Alignment = Alignment.CORNER,
+              name: str | None = None) -> 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.
 
@@ -1103,19 +1192,19 @@ class PCB:
         
         origin: tuple[float, ...] = origin + (z*self.unit, ) # type: ignore
 
-        if alignment == 'center':
+        if alignment is Alignment.CENTER:
             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)) # type: ignore
+        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(COPPER)
+        plane.set_material(self.trace_material)
         return plane # type: ignore
     
     def generate_pcb(self, 
                 split_z: bool = True,
-                layer_tolerance: float = 1e-6,
                 merge: bool = True) -> GeoVolume:
         """Generate the PCB Block object
 
@@ -1123,37 +1212,38 @@ class PCB:
             GeoVolume: The PCB Block
         """
         x0, y0, z0 = self.origin*self.unit
-
-        if split_z:
-            zvalues = sorted(list(set(self.zs + [-self.thickness, 0.0])))
-            zvalues_isolated = [zvalues[0],]
-            for z in zvalues[1:]:
-                if (z-zvalues_isolated[-1]) <= layer_tolerance:
-                    continue
-                zvalues_isolated.append(z)
+        
+        Nmats = len(set([layer.mat.name for layer in self._stack]))
+        
+        if split_z and self._zs.shape[0]>2 or Nmats > 1:
+            
             boxes: list[GeoVolume] = []
-            for z1, z2 in zip(zvalues_isolated[:-1],zvalues_isolated[1:]):
+            for i, (z1, z2, layer) in enumerate(zip(self._zs[:-1],self._zs[1:],self._stack)):
                 h = z2-z1
                 box = Box(self.width*self.unit,
                           self.length*self.unit,
                           h*self.unit,
-                          position=(x0, y0, z0+z1*self.unit))
-                box.material = self.material
+                          position=(x0, y0, z0+z1*self.unit),
+                          name=f'{self.name}_layer{i}')
+                box.material = layer.mat
                 box = change_coordinate_system(box, self.cs)
+                box.prio_set(self.dielectric_priority)
                 boxes.append(box)
-            if merge:
-                return GeoVolume.merged(boxes) # type: ignore
+            if merge and Nmats == 1:
+                return GeoVolume.merged(boxes).prio_set(self.dielectric_priority) # type: ignore
             return boxes # type: ignore
         
         box = Box(self.width*self.unit, 
                   self.length*self.unit, 
                   self.thickness*self.unit, 
-                  position=(x0,y0,z0-self.thickness*self.unit))
-        box.material = self.material
+                  position=(x0,y0,z0-self.thickness*self.unit),
+                  name=f'{self.name}_diel')
+        box.material = self._stack[0].mat
+        box.prio_set(self.dielectric_priority)
         box = change_coordinate_system(box, self.cs)
         return box # type: ignore
 
-    def generate_air(self, height: float) -> GeoVolume:
+    def generate_air(self, height: float, name: str = 'PCBAirbox') -> GeoVolume:
         """Generate the Air Block object
 
         This requires that the width, depth and origin are deterimed. This 
@@ -1166,7 +1256,8 @@ class PCB:
         box = Box(self.width*self.unit, 
                   self.length*self.unit, 
                   height*self.unit, 
-                  position=(x0,y0,z0))
+                  position=(x0,y0,z0),
+                  name=name)
         box = change_coordinate_system(box, self.cs)
         return box # type: ignore
 
@@ -1175,7 +1266,8 @@ class PCB:
             y: float, 
             width: float, 
             direction: tuple[float, float],
-            z: float = 0) -> StripPath:
+            z: float = 0,
+            name: str | None = None) -> StripPath:
         """Start a new trace
 
         The trace is started at the provided x,y, coordinates with a width "width".
@@ -1194,12 +1286,12 @@ class PCB:
         >>> PCB.new(...).straight(...).turn(...).straight(...) etc.
 
         """
-        path = StripPath(self)
+        path = StripPath(self, name=name)
         path.init(x, y, width, direction, z=z)
         self.paths.append(path)  
         return path
     
-    def lumped_port(self, stripline: StripLine, z_ground: float | None = None) -> GeoPolygon:
+    def lumped_port(self, stripline: StripLine, z_ground: float | None = None, name: str | None = 'LumpedPort') -> GeoPolygon:
         """Generate a lumped-port object to be created.
 
         Args:
@@ -1231,7 +1323,7 @@ class PCB:
         
         tag_wire = gmsh.model.occ.addWire(ltags)
         planetag = gmsh.model.occ.addPlaneSurface([tag_wire,])
-        poly = GeoPolygon([planetag,])
+        poly = GeoPolygon([planetag,], name='name')
         poly._aux_data['width'] = stripline.width*self.unit
         poly._aux_data['height'] = height*self.unit
         poly._aux_data['vdir'] = self.cs.zax
@@ -1239,19 +1331,18 @@ class PCB:
         
         return poly
 
-    def _lumped_element(self, poly: XYPolygon, function: Callable, width: float, length: float) -> None:
-
-        geopoly = poly._finalize(self.cs)
+    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,
                   width_multiplier: float = 5.0,
+                  name: str | None = 'ModalPort'
                   ) -> GeoSurface:
         """Generate a wave-port as a GeoSurface.
 
@@ -1277,7 +1368,7 @@ class PCB:
         ax1 = np.array([ds[0], ds[1], 0])*self.unit*point.width*width_multiplier
         ax2 = np.array([0,0,1])*height*self.unit
 
-        plate = Plate(np.array([x0,y0,z0])*self.unit, ax1, ax2)
+        plate = Plate(np.array([x0,y0,z0])*self.unit, ax1, ax2, name=name)
         plate = change_coordinate_system(plate, self.cs)
         return plate # type: ignore
 
@@ -1304,7 +1395,8 @@ class PCB:
             xg, yg, zg = self.cs.in_global_cs(x0, y0, z0)
             cs = CoordinateSystem(self.cs.xax, self.cs.yax, self.cs.zax, np.array([xg, yg, zg]))
             cyl = Cylinder(via.radius*self.unit, (via.z2-via.z1)*self.unit, cs, via.segments)
-            cyl.material = COPPER
+            cyl.material = self.trace_material
+            cyl.prio_set(self.via_priority)
             vias.append(cyl)
         if merge:
             
@@ -1315,7 +1407,8 @@ class PCB:
                  xs: list[float],
                  ys: list[float],
                  z: float = 0,
-                 material: Material = COPPER) -> None:
+                 material: Material = None,
+                 name: str | None = None) -> None:
         """Add a custom polygon to the PCB
 
         Args:
@@ -1324,9 +1417,14 @@ class PCB:
             z (float, optional): The z-height. Defaults to 0.
             material (Material, optional): The material. Defaults to COPPER.
         """
-        self.polies.append(PCBPoly(xs, ys, z, material))
+        if material is None:
+            material = self.trace_material
+        poly = PCBPoly(xs, ys, z, material,name=name)
+        
+        self.polies.append(poly)
+        
 
-    def _gen_poly(self, xys: list[tuple[float, float]], z: float) -> GeoPolygon:
+    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:
@@ -1340,7 +1438,8 @@ class PCB:
         
         tag_wire = gmsh.model.occ.addWire(ltags)
         planetag = gmsh.model.occ.addPlaneSurface([tag_wire,])
-        poly = GeoPolygon([planetag,])
+        poly = GeoPolygon([planetag,], name=name)
+        poly._store('thickness', self.thickness)
         return poly
     
     @overload
@@ -1385,12 +1484,12 @@ class PCB:
                     ally.append(y)
             
             poly = self._gen_poly(xys2, z)
-            poly.material = COPPER
+            poly.material = self.trace_material
             polys.append(poly)
 
         for pcbpoly in self.polies:
             self.zs.append(pcbpoly.z)
-            poly = self._gen_poly(pcbpoly.xys, pcbpoly.z)
+            poly = self._gen_poly(pcbpoly.xys, pcbpoly.z, name=pcbpoly.name)
             poly.material = pcbpoly.material
             polys.append(poly)
             xs, ys = zip(*pcbpoly.xys)
@@ -1407,14 +1506,4 @@ class PCB:
             polys = unite(*polys)
             
         return polys
-                
-############################################################
-#                        DEPRICATED                       #
-############################################################
-
-class PCBLayouter(PCB):
 
-    def __init__(self, *args, **kwargs):
-        logger.warning('PCBLayouter will be depricated. Use PCB instead.')
-        super().__init__(*args, **kwargs)
-