emerge 1.0.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "1.0.0"
+__version__ = "1.0.2"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -27,17 +27,16 @@ __version__ = "1.0.0"
 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
 os.environ["NUMEXPR_NUM_THREADS"] = NTHREADS
 
-
 ############################################################
 #                      IMPORT MODULES                     #
 ############################################################
-from ._emerge import _cache_check
+
 from ._emerge.logsettings import LOG_CONTROLLER
 from loguru import logger
 
@@ -54,8 +53,7 @@ from ._emerge.coord import Line
 from ._emerge import geo
 from ._emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
 from ._emerge.geometry import select
-from ._emerge.mth.common_functions import norm, coax_rout, coax_rin
-from ._emerge.physics.microwave.sc import stratton_chu
+#from ._emerge.mth.common_functions import norm, coax_rout, coax_rin
 from ._emerge.periodic import RectCell, HexCell
 from ._emerge.mesher import Algorithm2D, Algorithm3D
 from . import lib
@@ -65,10 +63,11 @@ howto = _HowtoClass()
 
 logger.debug('Importing complete!')
 
-
 ############################################################
 #                         CONSTANTS                        #
 ############################################################
 
 CENTER = geo.Alignment.CENTER
-CORNER = geo.Alignment.CORNER
+CORNER = geo.Alignment.CORNER
+EISO = lib.EISO
+EOMNI = lib.EOMNI

emerge/_emerge/elements/femdata.py

@@ -19,9 +19,7 @@ from __future__ import annotations
 from ..mesh3d import Mesh3D
 import numpy as np
 from typing import Callable
-from scipy.sparse import csr_matrix # type: ignore
 
-from ..mth.optimized import matmul
 
 class FEMBasis:
 
@@ -48,6 +46,8 @@ class FEMBasis:
     
     def interpolate_Ef(self, field: np.ndarray, basis: np.ndarray | None = None, origin: np.ndarray | None = None, tetids: np.ndarray | None = None) -> Callable:
         '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
+        from ..mth.optimized import matmul
+        
         if basis is None:
             basis = np.eye(3)
 
@@ -124,7 +124,8 @@ class FEMBasis:
         N = self.n_tri_dofs**2
         return slice(itri*N,(itri+1)*N)
     
-    def generate_csr(self, data: np.ndarray) -> csr_matrix:
+    def generate_csr(self, data: np.ndarray):
+        from scipy.sparse import csr_matrix # type: ignore
         ids = np.argwhere(data!=0)[:,0]
         return csr_matrix((data[ids], (self._rows[ids], self._cols[ids])), shape=(self.n_field, self.n_field))
     ### QUANTITIES

emerge/_emerge/elements/nedelec2.py

@@ -19,9 +19,6 @@ from __future__ import annotations
 import numpy as np
 from ..mesh3d import Mesh3D
 from .femdata import FEMBasis
-from .ned2_interp import ned2_tet_interp, ned2_tet_interp_curl
-from ..mth.optimized import local_mapping
-from .index_interp import index_interp
 
 ############### Nedelec2 Class
 
@@ -72,6 +69,7 @@ class Nedelec2(FEMBasis):
         ''' 
         Interpolate the provided field data array at the given xs, ys and zs coordinates
         '''
+        from .ned2_interp import ned2_tet_interp
         if tetids is None:
             tetids = self._all_tet_ids
         vals = ned2_tet_interp(np.array([xs, ys, zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, tetids)
@@ -83,8 +81,11 @@ class Nedelec2(FEMBasis):
         """
         Interpolates the curl of the field at the given points.
         """
+        from .ned2_interp import ned2_tet_interp_curl
+        
         if tetids is None:
             tetids = self._all_tet_ids
+        
         vals = ned2_tet_interp_curl(np.array([xs, ys, zs]), field, self.mesh.tets, self.mesh.tris, self.mesh.edges, self.mesh.nodes, self.tet_to_field, c, tetids)
         if not usenan:
             vals = np.nan_to_num(vals)
@@ -97,7 +98,7 @@ class Nedelec2(FEMBasis):
                         usenan: bool = True) -> np.ndarray:
         if tetids is None:
             tetids = self._all_tet_ids
-
+        from .index_interp import index_interp
         vals = index_interp(np.array([xs, ys, zs]), self.mesh.tets, self.mesh.nodes, tetids)
         if not usenan:
             vals[vals==-1]==0
@@ -106,15 +107,18 @@ class Nedelec2(FEMBasis):
     ###### INDEX MAPPINGS
 
     def local_tet_to_triid(self, itet: int) -> np.ndarray:
+        from ..mth.optimized import local_mapping
         tri_ids = self.tet_to_field[6:10, itet] - self.n_edges
         global_tri_map = self.mesh.tris[:, tri_ids]
         return local_mapping(self.mesh.tets[:, itet], global_tri_map)
 
     def local_tet_to_edgeid(self, itet: int) -> np.ndarray:
+        from ..mth.optimized import local_mapping
         global_edge_map = self.mesh.edges[:, self.tet_to_field[:6,itet]]
         return local_mapping(self.mesh.tets[:, itet], global_edge_map)
 
     def local_tri_to_edgeid(self, itri: int) -> np.ndarray:
+        from ..mth.optimized import local_mapping
         global_edge_map = self.mesh.edges[:, self.tri_to_field[:3,itri]]
         return local_mapping(self.mesh.tris[:, itri], global_edge_map)
     

emerge/_emerge/elements/nedleg2.py

@@ -19,8 +19,6 @@ from __future__ import annotations
 import numpy as np
 from ..mesh3d import SurfaceMesh
 from .femdata import FEMBasis
-from .ned2_interp import ned2_tri_interp_full, ned2_tri_interp_curl
-from ..mth.optimized import matinv
 from ..cs import CoordinateSystem
 from ..const import MU0, C0
 
@@ -74,6 +72,8 @@ class FieldFunctionClass:
         return np.array([Fx, Fy, Fz])*self.constant
     
     def calcE(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_full
+        
         coordinates = np.array([xs, ys])
         vals = ned2_tri_interp_full(coordinates, 
                                self.field, 
@@ -85,6 +85,7 @@ class FieldFunctionClass:
         return vals
     
     def calcH(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_curl
         coordinates = np.array([xs, ys])
         
         vals = ned2_tri_interp_curl(coordinates, 
@@ -176,6 +177,7 @@ class NedelecLegrange2(FEMBasis):
 
     def interpolate_Hf(self, field: np.ndarray, k0: float, ur: np.ndarray, beta: float) -> FieldFunctionClass:
         '''Generates the Interpolation function as a function object for a given coordiante basis and origin.'''
+        from ..mth.optimized import matinv
         constant = 1j / ((k0*C0)*MU0)
         urinv = np.zeros_like(ur)
         
@@ -185,6 +187,7 @@ class NedelecLegrange2(FEMBasis):
         return FieldFunctionClass(field, self.cs, self.local_nodes, self.mesh.tris, self.tri_to_field, 'H', urinv, beta, constant)
     
     def tri_interpolate(self, field, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_full
         coordinates = np.array([xs, ys])
         vals = ned2_tri_interp_full(coordinates, 
                                field, 
@@ -196,6 +199,7 @@ class NedelecLegrange2(FEMBasis):
         return vals
     
     def tri_interpolate_curl(self, field, xs: np.ndarray, ys: np.ndarray, diadic: np.ndarray | None = None, beta: float = 0.0, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        from .ned2_interp import ned2_tri_interp_curl
         coordinates = np.array([xs, ys])
         if diadic is None:
             diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.mesh.n_tris)) # type: ignore

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

@@ -20,7 +20,7 @@ from __future__ import annotations
 from ..cs import CoordinateSystem, GCS, Axis
 from ..geometry import GeoPolygon, GeoVolume, GeoSurface
 from ..material import Material, AIR, COPPER, PEC
-from .shapes import Box, Plate, Cylinder
+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 = PEC):
-        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,11 +933,21 @@ 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,
@@ -908,20 +955,55 @@ class PCB:
                  material: Material = AIR,
                  trace_material: Material = PEC,
                  layers: int = 2,
+                 stack: list[PCBLayer] = None,
+                 name: str | None = None,
+                 trace_thickness: float | None = None,
+                 zs: np.ndarray | 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 zs is not None:
+            self._zs = zs
+            self.thickness = np.max(zs)-np.min(zs)
+            self._stack = [PCBLayer(th, material) for th in np.diff(self._zs)]
+        elif 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
 
@@ -946,6 +1028,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 = []
@@ -1029,6 +1113,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:
@@ -1085,7 +1172,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.
 
@@ -1108,19 +1196,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(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
 
@@ -1128,39 +1216,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:
+            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 
@@ -1173,7 +1260,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
 
@@ -1182,7 +1270,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".
@@ -1201,12 +1290,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:
@@ -1238,7 +1327,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
@@ -1246,19 +1335,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.
 
@@ -1284,7 +1372,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
 
@@ -1323,7 +1411,8 @@ class PCB:
                  xs: list[float],
                  ys: list[float],
                  z: float = 0,
-                 material: Material = None) -> None:
+                 material: Material = None,
+                 name: str | None = None) -> None:
         """Add a custom polygon to the PCB
 
         Args:
@@ -1334,9 +1423,12 @@ class PCB:
         """
         if material is None:
             material = self.trace_material
-        self.polies.append(PCBPoly(xs, ys, z, 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:
@@ -1350,7 +1442,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
@@ -1400,7 +1493,7 @@ class PCB:
 
         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)
@@ -1417,14 +1510,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)
-