emerge 0.6.6__tar.gz → 0.6.8__tar.gz

{emerge-0.6.6 → emerge-0.6.8}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.6.6"
+current_version = "0.6.8"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{emerge-0.6.6 → emerge-0.6.8}/.gitignore

@@ -8,8 +8,8 @@ wheels/
 
 # Virtual environments
 .venv
-.vscode
 .mypy_cache
+environment.yml
 
 # paths
 meshes/
@@ -46,4 +46,5 @@ wheelhouse/
 .pytest_cache/
 
 .vscode/
+.idea/
 pytest.ini

{emerge-0.6.6 → emerge-0.6.8}/LICENSE

@@ -1,5 +1,5 @@
 ──────────────────────────────────────────────────────────────────────────────
-PREAMBLE — Licence map and disclaimers (not part of the GNU GPL text)
+PREAMBLE - Licence map and disclaimers (not part of the GNU GPL text)
 ──────────────────────────────────────────────────────────────────────────────
 This repository is distributed under two distinct licences:
 
@@ -11,7 +11,7 @@ This repository is distributed under two distinct licences:
     When you distribute binaries containing these components, the complete
     corresponding source code must be offered under GPL-2.0+.
 
-  • **`lib.py` — materials-property database**  
+  • **`lib.py` - materials-property database**  
     This single file is dedicated to the public domain under **CC0 1.0**.
     You may copy, modify, merge, publish, distribute, sublicense and/or sell
     copies of `lib.py` without restriction.  The data it contains are

{emerge-0.6.6 → emerge-0.6.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.6.6
+Version: 0.6.8
 Summary: An open source EM FEM simulator in Python
 Project-URL: Homepage, https://github.com/FennisRobert/EMerge
 Project-URL: Issues, https://github.com/FennisRobert/EMerge/issues

{emerge-0.6.6 → emerge-0.6.8}/emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.6"
+__version__ = "0.6.8"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -45,7 +45,7 @@ LOG_CONTROLLER.set_default()
 logger.debug('Importing modules')
 
 from ._emerge.simmodel import Simulation
-from ._emerge.material import Material
+from ._emerge.material import Material, FreqCoordDependent, FreqDependent, CoordDependent
 from ._emerge import bc
 from ._emerge.solver import SolverBicgstab, SolverGMRES, SolveRoutine, ReverseCuthillMckee, Sorter, SolverPardiso, SolverUMFPACK, SolverSuperLU, EMSolver
 from ._emerge.cs import CoordinateSystem, CS, GCS, Plane, Axis, XAX, YAX, ZAX, XYPLANE, XZPLANE, YZPLANE, YXPLANE, ZXPLANE, ZYPLANE

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/_cache_check.py

@@ -22,7 +22,7 @@ _COMPILE_MESSAGE = """
  [ EMERGE ]
 ⚠  Numba is compiling optimized code; this may take a few minutes.
    • Additional functions may be compiled on-the-fly.
-   • Compilation happens only once—subsequent runs load from cache.
+   • Compilation happens only once-subsequent runs load from cache.
    Please wait…"""
 
 @njit(cache=True)

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/elements/femdata.py

@@ -64,7 +64,7 @@ class FEMBasis:
     def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         raise NotImplementedError()
     
-    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, constants: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, constants: np.ndarray, tetids: np.ndarray | None = None, usenan: bool = True) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Interpolates the curl of the field at the given points.
         """
@@ -151,7 +151,8 @@ class FEMBasis:
     def interpolate_index(self, xs: np.ndarray,
                     ys: np.ndarray,
                     zs: np.ndarray,
-                    tetids: np.ndarray | None = None) -> np.ndarray:
+                    tetids: np.ndarray | None = None,
+                    usenan: bool = True) -> np.ndarray:
         raise NotImplementedError()
     
     def map_edge_to_field(self, edge_ids: np.ndarray) -> np.ndarray:

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/elements/index_interp.py

@@ -27,9 +27,8 @@ def index_interp(coords: np.ndarray,
     # Solution has shape (nEdges, nsols)
     nNodes = coords.shape[1]
     
-    prop = np.zeros((nNodes, ), dtype=np.int64)
+    prop = np.full((nNodes, ), -1, dtype=np.int64)
     
-
     for i_iter in range(tetids.shape[0]):
         itet = tetids[i_iter]
         

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/elements/ned2_interp.py

@@ -130,10 +130,10 @@ def ned2_tet_interp(coords: np.ndarray,
     ys = coords[1,:]
     zs = coords[2,:]
 
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), dtype=np.complex128)
-
+    Ex = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ey = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ez = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    
     for i_iter in range(tetids.shape[0]):
         itet = tetids[i_iter]
 
@@ -259,9 +259,9 @@ def ned2_tet_interp_curl(coords: np.ndarray,
     ys = coords[1,:]
     zs = coords[2,:]
 
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), dtype=np.complex128)
+    Ex = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ey = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ez = np.full((nNodes, ), np.nan, dtype=np.complex128)
 
     for i_iter in range(tetids.shape[0]):
         itet = tetids[i_iter]
@@ -382,9 +382,9 @@ def ned2_tri_interp(coords: np.ndarray,
     xs = coords[0,:]
     ys = coords[1,:]
 
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), dtype=np.complex128)
+    Ex = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ey = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ez = np.full((nNodes, ), np.nan, dtype=np.complex128)
 
     nodes = nodes[:2,:]
 
@@ -491,9 +491,9 @@ def ned2_tri_interp_full(coords: np.ndarray,
     xs = coords[0,:]
     ys = coords[1,:]
 
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), dtype=np.complex128)
+    Ex = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ey = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ez = np.full((nNodes, ), np.nan, dtype=np.complex128)
 
     nodes = nodes[:2,:]
 
@@ -572,9 +572,9 @@ def ned2_tri_interp_curl(coords: np.ndarray,
     xs = coords[0,:]
     ys = coords[1,:]
     jB = 1j*beta
-    Ex = np.zeros((nNodes, ), dtype=np.complex128)
-    Ey = np.zeros((nNodes, ), dtype=np.complex128)
-    Ez = np.zeros((nNodes, ), dtype=np.complex128)
+    Ex = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ey = np.full((nNodes, ), np.nan, dtype=np.complex128)
+    Ez = np.full((nNodes, ), np.nan, dtype=np.complex128)
 
     nodes = nodes[:2,:]
 

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/elements/nedelec2.py

@@ -68,30 +68,41 @@ class Nedelec2(FEMBasis):
 
         self.empty_tri_rowcol()
     
-    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, tetids: np.ndarray | None = None, usenan: bool = True) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         ''' 
         Interpolate the provided field data array at the given xs, ys and zs coordinates
         '''
         if tetids is None:
             tetids = self._all_tet_ids
-        return 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)
+        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)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals
     
-    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray, tetids: np.ndarray | None = None) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def interpolate_curl(self, field: np.ndarray, xs: np.ndarray, ys: np.ndarray, zs:np.ndarray, c: np.ndarray, tetids: np.ndarray | None = None, usenan: bool = True) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Interpolates the curl of the field at the given points.
         """
         if tetids is None:
             tetids = self._all_tet_ids
-        return 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)
+        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)
+        return vals
     
     def interpolate_index(self, xs: np.ndarray,
                         ys: np.ndarray,
                         zs: np.ndarray,
-                        tetids: np.ndarray | None = None) -> np.ndarray:
+                        tetids: np.ndarray | None = None,
+                        usenan: bool = True) -> np.ndarray:
         if tetids is None:
             tetids = self._all_tet_ids
 
-        return index_interp(np.array([xs, ys, zs]), self.mesh.tets, self.mesh.nodes, tetids)
+        vals = index_interp(np.array([xs, ys, zs]), self.mesh.tets, self.mesh.nodes, tetids)
+        if not usenan:
+            vals[vals==-1]==0
+        return vals
+    
     ###### INDEX MAPPINGS
 
     def local_tet_to_triid(self, itet: int) -> np.ndarray:

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/elements/nedleg2.py

@@ -73,24 +73,30 @@ class FieldFunctionClass:
         Fx, Fy, Fz = self.cs.in_global_basis(Fxl, Fyl, Fzl)
         return np.array([Fx, Fy, Fz])*self.constant
     
-    def calcE(self, xs: np.ndarray, ys: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def calcE(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         coordinates = np.array([xs, ys])
-        return ned2_tri_interp_full(coordinates, 
+        vals = ned2_tri_interp_full(coordinates, 
                                self.field, 
                                self.tris,  
                                self.nodes, 
                                self.tri_to_field)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals
     
-    def calcH(self, xs: np.ndarray, ys: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def calcH(self, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         coordinates = np.array([xs, ys])
         
-        return ned2_tri_interp_curl(coordinates, 
+        vals = ned2_tri_interp_curl(coordinates, 
                                self.field, 
                                self.tris,  
                                self.nodes, 
                                self.tri_to_field,
                                self.diadic,
                                self.beta)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals
 
 ############### Nedelec2 Class
 
@@ -178,22 +184,28 @@ 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) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    def tri_interpolate(self, field, xs: np.ndarray, ys: np.ndarray, usenan: bool = False) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         coordinates = np.array([xs, ys])
-        return ned2_tri_interp_full(coordinates, 
+        vals = ned2_tri_interp_full(coordinates, 
                                field, 
                                self.mesh.tris,  
                                self.local_nodes, 
                                self.tri_to_field)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals
     
-    def tri_interpolate_curl(self, field, xs: np.ndarray, ys: np.ndarray, diadic: np.ndarray | None = None, beta: float = 0.0) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+    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]:
         coordinates = np.array([xs, ys])
         if diadic is None:
             diadic = np.eye(3)[:,:,np.newaxis()] * np.ones((self.mesh.n_tris)) # type: ignore
-        return ned2_tri_interp_curl(coordinates, 
+        vals = ned2_tri_interp_curl(coordinates, 
                                field, 
                                self.mesh.tris,  
                                self.local_nodes, 
                                self.tri_to_field,
                                diadic,
-                               beta)
+                               beta)
+        if not usenan:
+            vals = np.nan_to_num(vals)
+        return vals

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/geo/__init__.py

@@ -19,6 +19,6 @@ from .pcb import PCB
 from .pmlbox import pmlbox
 from .horn import Horn
 from .shapes import Cylinder, CoaxCylinder, Box, XYPlate, HalfSphere, Sphere, Plate, OldBox, Alignment, Cone
-from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect, unite
+from .operations import subtract, add, embed, remove, rotate, mirror, change_coordinate_system, translate, intersect, unite, expand_surface, stretch
 from .polybased import XYPolygon, GeoPrism, Disc, Curve
 from .step import STEPItems

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/geo/horn.py

@@ -17,7 +17,6 @@
 
 from ..geometry import GeoVolume
 from ..cs import CoordinateSystem
-from ..selection import FaceSelection
 
 import gmsh # type: ignore
 

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/geo/modeler.py

@@ -381,7 +381,7 @@ class Modeler:
         self._add_function(function)
         return self
     
-    def cyllinder(self,
+    def cylinder(self,
                   radius: float | Series,
                   height: float | Series,
                   position: tuple[float | Series, float | Series, float | Series],

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/geo/operations.py

@@ -60,7 +60,7 @@ def add(main: T, tool: T,
         main._exists = False
     if remove_tool:
         tool._exists = False
-    return output # type: ignore
+    return output.set_material(main.material) # type: ignore
 
 def remove(main: T, tool: T, 
              remove_object: bool = True,
@@ -90,7 +90,7 @@ def remove(main: T, tool: T,
         main._exists = False
     if remove_tool:
         tool._exists = False
-    return output # type: ignore
+    return output.set_material(main.material) # type: ignore
 
 subtract = remove
 
@@ -122,7 +122,7 @@ def intersect(main: T, tool: T,
         main._exists = False
     if remove_tool:
         tool._exists = False
-    return output #type:ignore
+    return output.set_material(main.material) #type:ignore
 
 def embed(main: GeoVolume, other: GeoSurface) -> None:
     ''' Embeds a surface into a volume in the GMSH model.
@@ -268,6 +268,19 @@ def change_coordinate_system(main: GeoObject,
         fp.affine_transform(M2)
     return main
 
+def stretch(main: GeoObject, fx: float = 1, fy: float = 1, fz: float = 1, origin: tuple[float, float, float] = (0.0, 0.0, 0.0)) -> GeoObject:
+    """Stretches a geometry with a factor fx, fy and fz along the x, y and Z axes respectively
+    
+    The stretch origin is centered at the provided origin.
+
+    Returns:
+        _type_: _description_
+    """
+    gmsh.model.occ.dilate(main.dimtags, *origin, fx, fy, fz)
+    
+    return main
+
+
 @overload
 def unite(*objects: GeoVolume) -> GeoVolume: ...
 
@@ -301,4 +314,31 @@ def unite(*objects: GeoObject) -> GeoObject:
     new_obj.set_material(main.material)
     new_obj.prio_set(main._priority)
     
-    return new_obj
+    return new_obj
+
+def expand_surface(surface: GeoSurface, distance: float) -> GeoSurface:
+    """EXPERIMENTAL: Expands an input surface. The surface must exist on a 2D plane.
+    
+    The output surface does not inherit material properties.
+    
+    If any problems occur, reach out through email.
+
+    Args:
+        surface (GeoSurface): The input surface to expand
+        distance (float): The exapansion distance
+
+    Returns:
+        GeoSurface: The output surface
+    """
+    surfs = [] 
+    for tag in surface.tags:
+        looptags, _ = gmsh.model.occ.get_curve_loops(tag)
+        new_curves = []
+        for looptag in looptags:
+            curve_tags = gmsh.model.occ.offset_curve(looptag, distance)
+            loop_tag = gmsh.model.occ.addCurveLoop([t for d,t in curve_tags])
+            new_curves.append(loop_tag)
+        surftag = gmsh.model.occ.addPlaneSurface(new_curves)
+        surfs.append(surftag)
+    surf = GeoSurface(surfs)
+    return surf

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/geo/pcb.py

@@ -963,8 +963,18 @@ class PCB:
         Returns:
             float: the z-height
         """
+        if layer <= 0:
+            return self._zs[layer]
         return self._zs[layer-1]
     
+    @property
+    def top(self) -> float:
+        return self._zs[-1]
+    
+    @property
+    def bottom(self) -> float:
+        return self._zs[0]
+    
     def _get_z(self, element: RouteElement) -> float :
         """Return the z-height of a given Route Element
 
@@ -979,6 +989,31 @@ class PCB:
                 return path.z
         raise RouteException('Requesting z-height of route element that is not contained in a path.')
 
+    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.
+        
+        Make sure to define the radius explicitly, otherwise the radius gets interpreted as a coordinate:
+        
+        >>> pcb.add_vias((x1,y1), (x1,y2), radius=1)
+
+        Args:
+            *coordinates (tuple(float, float)): A series of coordinates
+            radius (float): The radius
+            z1 (float | None, optional): The bottom z-coordinate. Defaults to None.
+            z2 (float | None, optional): The top z-coordinate. Defaults to None.
+            segments (int, optional): The number of segmets for the via. Defaults to 6.
+        """
+        if z1 is None:
+            z1 = self.z(0)
+        if z2 is None:
+            z2 = self.z(-1)
+        
+        for x,y in coordinates:
+            self.vias.append(Via(x,y,z1,z2,radius,segments))
+        
     def load(self, name: str) -> StripLine:
         """Acquire the x,y, coordinate associated with the label name.
         
@@ -1060,7 +1095,7 @@ 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:
+            if self.width is None or self.length is None or self.origin is None:
                 raise RouteException('Cannot define a plane with no possible definition of its size.')
             width = self.width
             height = self.length
@@ -1075,6 +1110,7 @@ class PCB:
 
         plane = Plate(origin, (width*self.unit, 0, 0), (0, height*self.unit, 0)) # type: ignore
         plane = change_coordinate_system(plane, self.cs) # type: ignore
+        plane.set_material(COPPER)
         return plane # type: ignore
     
     def generate_pcb(self, 
@@ -1121,7 +1157,7 @@ class PCB:
         """Generate the Air Block object
 
         This requires that the width, depth and origin are deterimed. This 
-        can either be done manually or via the .determine_boudns() method.
+        can either be done manually or via the .determine_bounds() method.
 
         Returns:
             GeoVolume: The PCB Block
@@ -1357,20 +1393,19 @@ class PCB:
             poly = self._gen_poly(pcbpoly.xys, pcbpoly.z)
             poly.material = pcbpoly.material
             polys.append(poly)
+            xs, ys = zip(*pcbpoly.xys)
+            allx.extend(xs)
+            ally.extend(ys)
+            
 
         self.xs = allx
         self.ys = ally
 
         self.traces = polys
+        
         if merge:
             polys = unite(*polys)
-            # tags = []
-            # for p in polys:
-            #     tags.extend(p.tags)
-            #     if p.material != COPPER:
-            #         logger.warning(f'Merging a polygon with material {p.material} into a single polygon that will be COPPER.')
-            # polys = GeoSurface(tags)
-            # polys.material = COPPER
+            
         return polys
                 
 ############################################################

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/geo/pcb_tools/calculator.py

@@ -20,9 +20,8 @@ class PCBCalculator:
         self.mat = material
         self.unit = unit
 
-
-    def z0(self, Z0: float, layer: int = -1, ground_layer: int = 0):
+    def z0(self, Z0: float, layer: int = -1, ground_layer: int = 0, f0: float = 1e9):
         th = abs(self.layers[layer] - self.layers[ground_layer])*self.unit
         ws = np.geomspace(1e-6,1e-1,101)
-        Z0ms = microstrip_z0(ws, th, self.mat.er)
+        Z0ms = microstrip_z0(ws, th, self.mat.er.scalar(f0))
         return np.interp(Z0, Z0ms[::-1], ws[::-1])/self.unit

{emerge-0.6.6 → emerge-0.6.8}/emerge/_emerge/geo/pmlbox.py

@@ -17,7 +17,7 @@
 
 from ..geometry import GeoVolume
 from .shapes import Box, Alignment, Plate
-from ..material import Material, AIR
+from ..material import Material, AIR, CoordDependent
 import numpy as np
 from functools import partial
 
@@ -31,6 +31,15 @@ def _add_pml_layer(center: tuple[float, float, float],
                    exponent: float,
                    deltamax: float,
                    material: Material) -> GeoVolume:
+    
+    if material.frequency_dependent:
+        raise ValueError('EMerge cannot handle frequency dependent material properties for PML layers at this point.')
+    if material.coordinate_dependent:
+        raise ValueError('Its not possible to define PML regions for materials that are coordinate dependent.')
+    
+    mater = material.er.scalar(1e9)
+    matur = material.ur.scalar(1e9)
+    
     px, py, pz = center
     W,D,H = dims
     dx, dy, dz = direction
@@ -69,15 +78,16 @@ def _add_pml_layer(center: tuple[float, float, float],
     
     def ermat(x, y, z):
         ers = np.zeros((3,3,x.shape[0]), dtype=np.complex128)
-        ers[0,0,:] = material.er * syf(x,y,z)*szf(x,y,z)/sxf(x,y,z)
-        ers[1,1,:] = material.er * szf(x,y,z)*sxf(x,y,z)/syf(x,y,z)
-        ers[2,2,:] = material.er * sxf(x,y,z)*syf(x,y,z)/szf(x,y,z)
+        ers[0,0,:] = mater * syf(x,y,z)*szf(x,y,z)/sxf(x,y,z)
+        ers[1,1,:] = mater * szf(x,y,z)*sxf(x,y,z)/syf(x,y,z)
+        ers[2,2,:] = mater * sxf(x,y,z)*syf(x,y,z)/szf(x,y,z)
         return ers
+    
     def urmat(x, y, z):
         urs = np.zeros((3,3,x.shape[0]), dtype=np.complex128)
-        urs[0,0,:] = material.ur * syf(x,y,z)*szf(x,y,z)/sxf(x,y,z)
-        urs[1,1,:] = material.ur * szf(x,y,z)*sxf(x,y,z)/syf(x,y,z)
-        urs[2,2,:] = material.ur * sxf(x,y,z)*syf(x,y,z)/szf(x,y,z)
+        urs[0,0,:] = matur * syf(x,y,z)*szf(x,y,z)/sxf(x,y,z)
+        urs[1,1,:] = matur * szf(x,y,z)*sxf(x,y,z)/syf(x,y,z)
+        urs[2,2,:] = matur * sxf(x,y,z)*syf(x,y,z)/szf(x,y,z)
         return urs
     
     pml_box = Box(*pml_block_size, new_center, alignment=Alignment.CENTER)
@@ -106,7 +116,9 @@ 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, color='#bbbbff', opacity=0.1)
+    erfunc = CoordDependent(max_value=mater, matrix=ermat)
+    urfunc = CoordDependent(max_value=matur, matrix=urmat)
+    pml_box.material = Material(er=erfunc, ur=urfunc,_neff=np.sqrt(mater*matur), color='#bbbbff', opacity=0.1)
     pml_box.max_meshsize = thickness/N_mesh_layers
     pml_box._embeddings = planes
     
@@ -121,9 +133,10 @@ def pmlbox(width: float,
             material: Material = AIR,
             thickness: float = 0.1,
             Nlayers: int = 1,
-            N_mesh_layers: int = 8,
+            N_mesh_layers: int = 5,
             exponent: float = 1.5,
             deltamax: float = 8.0,
+            sides: str = '',
             top: bool = False,
             bottom: bool = False,
             left: bool = False,
@@ -145,10 +158,11 @@ def pmlbox(width: float,
         alignment (Alignment, optional): Which point of the box is placed at the given coordinate. Defaults to Alignment.CORNER.
         material (Material, optional): The material of the box. Defaults to AIR.
         thickness (float, optional): The thickness of the PML Layer. Defaults to 0.1.
-        Nlayers (int, optional): The number of PML layers (1 is reccomended). Defaults to 1.
-        N_mesh_layers (int, optional): The number of mesh layers. Sets the discretization size accordingly. Defaults to 8
+        Nlayers (int, optional): The number of geometrical PML layers. Defaults to 1.
+        N_mesh_layers (int, optional): The number of mesh layers. Sets the discretization size accordingly. Defaults to 5
         exponent (float, optional): The PML gradient growth function. Defaults to 1.5.
         deltamax (float, optional): A PML matching coefficient. Defaults to 8.0.
+        sides (str, optional): A string of pml sides as characters ([T]op, [B]ottom, [L]eft, [R]ight, [F]ront, b[A]ck)
         top (bool, optional): Add a top PML layer. Defaults to True.
         bottom (bool, optional): Add a bottom PML layer. Defaults to False.
         left (bool, optional): Add a left PML layer. Defaults to False.
@@ -159,6 +173,16 @@ def pmlbox(width: float,
     Returns:
         list[GeoVolume]: A list of objects [main box, *pml boxes]
     """
+    
+    sides = sides.lower()
+
+    top    = "t" in sides or top
+    bottom = "b" in sides or bottom
+    left   = "l" in sides or left
+    right  = "r" in sides or right
+    front  = "f" in sides or front
+    back   = "a" in sides or back
+
     px, py, pz = position
     if alignment == Alignment.CORNER:
         px = px + width / 2