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

emerge/_emerge/geometry.py

@@ -33,6 +33,7 @@ def _map_tags(tags: list[int], mapping: dict[int, list[int]]):
 
 def _bbcenter(x1, y1, z1, x2, y2, z2):
     return np.array([(x1+x2)/2, (y1+y2)/2, (z1+z2)/2])
+
 FaceNames = Literal['back','front','left','right','top','bottom']
 
 class _KEY_GENERATOR:
@@ -47,29 +48,50 @@ class _KEY_GENERATOR:
 class _GeometryManager:
 
     def __init__(self):
-        self.geometry_list: dict[str, list[GeoObject]] = dict()
+        self.geometry_list: dict[str, dict[str, GeoObject]] = dict()
         self.active: str = ''
+        self.geometry_names: dict[str, set[str]] = dict()
 
+    def get_surfaces(self) -> list[GeoSurface]:
+        return [geo for geo in self.all_geometries() if geo.dim==2]
+    
     def all_geometries(self, model: str | None = None) -> list[GeoObject]:
         if model is None:
             model = self.active
-        return [geo for geo in self.geometry_list[model] if geo._exists]
+        return [geo for geo in self.geometry_list[model].values() if geo._exists]
 
+    def all_names(self, model: str | None = None) -> set[str]:
+        if model is None:
+            model = self.active
+        return self.geometry_names[model]
+    
+    def get_name(self, suggestion: str, model: str | None = None) -> str:
+        names = self.all_names(model)
+        if suggestion not in names:
+            return suggestion
+        for i in range(1_000_000):
+            if f'{suggestion}_{i}' not in names:
+                return f'{suggestion}_{i}'
+        raise RuntimeError('Cannot generate a unique name.')
+        
     def submit_geometry(self, geo: GeoObject, model: str | None = None) -> None:
         if model is None:
             model = self.active
-        self.geometry_list[model].append(geo)
+        self.geometry_list[model][geo.name] = geo
+        self.geometry_names[model].add(geo.name)
 
     def sign_in(self, modelname: str) -> None:
         # if modelname not in self.geometry_list:
         #     self.geometry_list[modelname] = []
         if modelname is self.geometry_list:
             logger.warning(f'{modelname} already exist, Geometries will be reset.')
-        self.geometry_list[modelname] = []
+        self.geometry_list[modelname] = dict()
+        self.geometry_names[modelname] = set()
         self.active = modelname
 
     def reset(self, modelname: str) -> None:
-        self.geometry_list[modelname] = []
+        self.geometry_list[modelname] = dict()
+        self.geometry_names[modelname] = set()
     
     def lowest_priority(self) -> int:
         return min([geo._priority for geo in self.all_geometries()])
@@ -216,7 +238,8 @@ class GeoObject:
     """A generalization of any OpenCASCADE entity described by a dimension and a set of tags.
     """
     dim: int = -1
-    def __init__(self, tags: list[int] | None = None):
+    _default_name: str = 'GeoObject'
+    def __init__(self, tags: list[int] | None = None, name: str | None = None):
         if tags is None:
             tags = []
         self.old_tags: list[int] = []
@@ -235,18 +258,63 @@ class GeoObject:
         self._priority: int = 10
 
         self._exists: bool = True
+        
+        self.give_name(name)
         _GEOMANAGER.submit_geometry(self)
 
+    def _store(self, name: str, data: Any) -> None:
+        """Store a property as auxilliary data under a given name
+
+        Args:
+            name (str): Name field
+            data (Any): Data to store
+        """
+        self._aux_data[name] = data
+
+    def _load(self, name: str) -> Any | None:
+        """Load data with a given name. If it doesn't exist, it returns None
+
+        Args:
+            name (str): The property to retreive
+
+        Returns:
+            Any | None: The property
+        """
+        return self._aux_data.get(name, None)
+    
+    def give_name(self, name: str | None = None) -> GeoObject:
+        """Assign a name to this object
+
+        Args:
+            name (str | None, optional): The name for the object. Defaults to None.
+        """
+        if name is None:
+            name = self._default_name
+        self.name: str = _GEOMANAGER.get_name(name)
+        return self
+    
     @property
     def color_rgb(self) -> tuple[float, float, float]:
+        """The color of the object in RGB float tuple
+
+        Returns:
+            tuple[float, float, float]: The color
+        """
         return self.material.color_rgb
     
     @property
     def opacity(self) -> float:
+        """The opacity of the object
+
+        Returns:
+            float: The opacity
+        """
         return self.material.opacity
     
     @property
     def _metal(self) -> bool:
+        """If the material should be rendered as metal
+        """
         return self.material._metal
     
     @property
@@ -263,6 +331,14 @@ class GeoObject:
     
     @staticmethod
     def merged(objects: list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject]) -> list[GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject] | GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject:
+        """Create a GeoObject by merging an iterable of GeoObjects
+
+        Args:
+            objects (list[GeoPoint  |  GeoEdge  |  GeoSurface  |  GeoVolume  |  GeoObject]): A list of geo objects
+
+        Returns:
+            GeoPoint | GeoEdge | GeoSurface | GeoVolume | GeoObject: The resultant object
+        """
         dim = objects[0].dim
         tags = []
         out: GeoObject | None = None
@@ -288,6 +364,17 @@ class GeoObject:
                           origin: np.ndarray | None = None,
                           normal: np.ndarray | None = None,
                           tag: int | None = None):
+        """Adds a face identifier (face pointer) to this object
+
+        Args:
+            name (str): The name for the face
+            origin (np.ndarray | None, optional): A point on the object. Defaults to None.
+            normal (np.ndarray | None, optional): The normal of the face. Defaults to None.
+            tag (int | None, optional): The tace tag used to extract the origin and normal. Defaults to None.
+
+        Raises:
+            ValueError: _description_
+        """
         if tag is not None:
             o = gmsh.model.occ.get_center_of_mass(2, tag)
             n = gmsh.model.get_normal(tag, (0,0))
@@ -299,6 +386,7 @@ class GeoObject:
         raise ValueError('Eitehr a tag or an origin + normal must be provided!')
     
     def make_copy(self) -> GeoObject:
+        """ Copies this object and returns a new object (also in GMSH)"""
         new_dimtags = gmsh.model.occ.copy(self.dimtags)
         new_obj = GeoObject.from_dimtags(new_dimtags)
         new_obj.material = self.material
@@ -316,6 +404,11 @@ class GeoObject:
         return new_obj
 
     def replace_tags(self, tagmap: dict[int, list[int]]):
+        """Replaces the GMSH tags assigned to this objects
+
+        Args:
+            tagmap (dict[int, list[int]]): A map that shows which tag is mapped to which set of new tags.
+        """
         self.old_tags = self.tags
         newtags = []
         for tag in self.tags:
@@ -391,6 +484,30 @@ class GeoObject:
         self._priority = level
         return self
     
+    def above(self, other: GeoObject) -> GeoObject:
+        """Puts the priority of this object one higher than the other, then returns this object
+
+        Args:
+            other (GeoObject): The other object to put below this object
+
+        Returns:
+            GeoObject: This object
+        """
+        self._priority = other._priority + 1
+        return self
+    
+    def below(self, other: GeoObject) -> GeoObject:
+        """Puts the priority of this object one lower than the other, then returns this object
+
+        Args:
+            other (GeoObject): The other object to put above this object
+
+        Returns:
+            GeoObject: This object
+        """
+        self._priority = other._priority -1
+        return self
+        
     def prio_up(self) -> GeoObject:
         """Increases the material selection priority by 1
 
@@ -427,7 +544,9 @@ class GeoObject:
         self._priority = _GEOMANAGER.highest_priority()+10
         return self
     
-    def boundary(self, exclude: tuple[FaceNames,...] | None = None, tags: list[int] | None = None) -> FaceSelection:
+    def boundary(self, exclude: tuple[FaceNames,...] | None = None, 
+                 tags: list[int] | None = None,
+                 tool: GeoObject | None = None) -> FaceSelection:
         """Returns the complete set of boundary faces.
 
         If implemented, it is possible to exclude a set of faces based on their name
@@ -444,7 +563,7 @@ class GeoObject:
         
         
         for name in exclude:
-            tags.extend(self.face(name).tags)
+            tags.extend(self.face(name, tool=tool).tags)
         dimtags = gmsh.model.get_boundary(self.dimtags, True, False)
         return FaceSelection([t for d,t in dimtags if t not in tags])
     
@@ -508,8 +627,10 @@ class GeoVolume(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not represent EMerge
     specific geometry data.'''
     dim = 3
-    def __init__(self, tag: int | Iterable[int]):
-        super().__init__()
+    _default_name: str = 'GeoVolume'
+    def __init__(self, tag: int | Iterable[int], name: str | None = None):
+        super().__init__(name=name)
+        
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
             self.tags = list(tag)
@@ -522,13 +643,14 @@ class GeoVolume(GeoObject):
     
 class GeoPoint(GeoObject):
     dim = 0
-
+    _default_name: str = 'GeoPoint'
+    
     @property
     def selection(self) -> PointSelection:
         return PointSelection(self.tags)
     
-    def __init__(self, tag: int | list[int]):
-        super().__init__()
+    def __init__(self, tag: int | list[int], name: str | None = None):
+        super().__init__(name=name)
 
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
@@ -538,13 +660,14 @@ class GeoPoint(GeoObject):
 
 class GeoEdge(GeoObject):
     dim = 1
-
+    _default_name: str = 'GeoEdge'
+    
     @property
     def selection(self) -> EdgeSelection:
         return EdgeSelection(self.tags)
     
-    def __init__(self, tag: int | list[int]):
-        super().__init__()
+    def __init__(self, tag: int | list[int], name: str | None = None):
+        super().__init__(name=name)
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
             self.tags = list(tag)
@@ -556,13 +679,14 @@ class GeoSurface(GeoObject):
     '''GeoVolume is an interface to the GMSH CAD kernel. It does not reprsent Emerge
     specific geometry data.'''
     dim = 2
-
+    _default_name: str = 'GeoSurface'
+    
     @property
     def selection(self) -> FaceSelection:
         return FaceSelection(self.tags)
     
-    def __init__(self, tag: int | list[int]):
-        super().__init__()
+    def __init__(self, tag: int | list[int], name: str | None = None):
+        super().__init__(name=name)
         self.tags: list[int] = []
         if isinstance(tag, Iterable):
             self.tags = list(tag)
@@ -570,10 +694,12 @@ class GeoSurface(GeoObject):
             self.tags = [tag,]
 
 class GeoPolygon(GeoSurface):
+    _default_name: str = 'GeoPolygon'
     
     def __init__(self,
-                 tags: list[int]):
-        super().__init__(tags)
+                 tags: list[int],
+                 name: str | None = None):
+        super().__init__(tags, name=name)
         self.points: list[int] = []
         self.lines: list[int] = []
 

emerge/_emerge/material.py

@@ -381,4 +381,5 @@ class Material:
         return self._color_rgb
      
 AIR = Material(color="#4496f3", opacity=0.05, name='Air')
-COPPER = Material(cond=5.8e7, color="#62290c", _metal=True, name='Copper')
+COPPER = Material(cond=5.8e7, color="#62290c", _metal=True, name='Copper')
+PEC = Material(color="#ff78aa", opacity=1.0, cond=1e30, _metal=True, name="PEC")

emerge/_emerge/mesh3d.py

@@ -122,7 +122,6 @@ class Mesh3D(Mesh):
         self.inv_tets: dict = dict()
 
         # Mappings
-
         self.tet_to_edge: np.ndarray = np.array([])
         self.tet_to_edge_sign: np.ndarray = np.array([])
         self.tet_to_tri: np.ndarray = np.array([])
@@ -133,7 +132,6 @@ class Mesh3D(Mesh):
         self.node_to_edge: defaultdict | dict = defaultdict()
 
         # Physics mappings
-
         self.tet_to_field: np.ndarray = np.array([])
         self.edge_to_field: np.ndarray = np.array([])
         self.tri_to_field: np.ndarray = np.array([])
@@ -149,6 +147,10 @@ class Mesh3D(Mesh):
         self.vtag_to_tet:  dict[int, list[int]] = dict()
         self.etag_to_edge: dict[int, list[int]] = dict()
         
+        ## Dervied
+        self.dimtag_to_center: dict[tuple[int, int], tuple[float, float, float]] = dict()
+        self.dimtag_to_edges: dict[tuple[int, int], np.ndarray] = dict()
+        
         self.exterior_face_tags: list[int] = []
     
     @property
@@ -242,7 +244,7 @@ class Mesh3D(Mesh):
 
         return np.array(indices)
     
-    def domain_edges(self, dimtags: list[tuple[int,int]]) -> np.ndarray:
+    def _domain_edge(self, dimtag: tuple[int,int]) -> np.ndarray:
         """Returns a np.ndarray of all edge indices corresponding to a set of dimension tags.
 
         Args:
@@ -252,21 +254,39 @@ class Mesh3D(Mesh):
             np.ndarray: The list of mesh edge element indices.
         """
         dimtags_edge = []
-        for (d,t) in dimtags:
-            if d==1:
-                dimtags_edge.append(t)
-            if d==2:
-                dimtags_edge.extend(gmsh.model.getBoundary([(d,t),], False, False))
-            if d==3:
-                dts = gmsh.model.getBoundary([(d,t),], False, False)
-                dimtags_edge.extend(gmsh.model.getBoundary(dts, False, False))
-        
+        d,t = dimtag
+        if d==0:
+            return np.ndarray([], dtype=np.int64)
+        if d==1:
+            dimtags_edge.append((1,t))
+        if d==2:
+            dimtags_edge.extend(gmsh.model.getBoundary([(d,t),], False, False))
+        if d==3:
+            dts = gmsh.model.getBoundary([(d,t),], False, False)
+            dimtags_edge.extend(gmsh.model.getBoundary(dts, False, False))
+    
         edge_ids = []
         for tag in dimtags_edge:
             edge_ids.extend(self.etag_to_edge[tag[1]])
         edge_ids = np.array(edge_ids)
         return edge_ids
+    
+    def domain_edges(self, dimtags: list[tuple[int,int]]) -> np.ndarray:
+        """Returns a np.ndarray of all edge indices corresponding to a set of dimension tags.
+
+        Args:
+            dimtags (list[tuple[int,int]]): A list of dimtags.
+
+        Returns:
+            np.ndarray: The list of mesh edge element indices.
+        """
         
+        edge_ids = []
+        for dt in dimtags:
+            edge_ids.extend(self.dimtag_to_edges[dt])
+        edge_ids = np.array(edge_ids)
+        return edge_ids
+    
     def get_face_tets(self, *taglist: list[int]) -> np.ndarray:
         ''' Return a list of a tetrahedrons that share a node with any of the nodes in the provided face.'''
         nodes: set = set()
@@ -487,6 +507,13 @@ class Mesh3D(Mesh):
             self.vtag_to_tet[t] = [self.get_tet(node_tags[0,i], node_tags[1,i], node_tags[2,i], node_tags[3,i]) for i in range(node_tags.shape[1])]
 
         self.defined = True
+        
+        for dim in (0,1,2,3):
+            dts= gmsh.model.get_entities(dim)
+            for dt in dts:
+                self.dimtag_to_center[dt] = gmsh.model.occ.get_center_of_mass(*dt)
+                self.dimtag_to_edges[dt] = self._domain_edge(dt)
+                
         logger.trace('Done analyzing mesh.')
 
 

emerge/_emerge/periodic.py

@@ -16,7 +16,7 @@
 # <https://www.gnu.org/licenses/>.
 
 from .cs import Axis, _parse_axis, GCS, _parse_vector
-from .selection import SELECTOR_OBJ, Selection
+from .selection import SELECTOR_OBJ, Selection, FaceSelection
 from .geo import GeoPrism, XYPolygon, Alignment, XYPlate
 from .bc import BoundaryCondition
 from typing import Generator
@@ -50,8 +50,8 @@ def _pair_selection(f1: Selection,
     for t1, c1 in zip(f1.tags, c1s):
         for t2, c2 in zip(f2.tags, c2s):
             if np.linalg.norm((c1 + ds)-c2) < 1e-8:
-                f1s.append(Selection([t1,]))
-                f2s.append(Selection([t2,]))
+                f1s.append(FaceSelection([t1,]))
+                f2s.append(FaceSelection([t2,]))
     return f1s, f2s
 
 
@@ -69,7 +69,7 @@ class PeriodicCell:
 
         self.origins: list[tuple[float, float, float]] = [_parse_vector(origin) for origin in origins] # type: ignore
         self.vectors: list[Axis] = [_parse_axis(vec) for vec in vectors]
-        self.excluded_faces: Selection | None = None
+        self.included_faces: Selection | None = None
         self._bcs: list[Periodic] = []
         self._ports: list[BoundaryCondition] = []
 
@@ -105,9 +105,11 @@ class PeriodicCell:
         for f1, f2, a in self.cell_data():
             f1_new = f1
             f2_new = f2
-            if self.excluded_faces is not None:
-                f1_new = f1 - self.excluded_faces # type: ignore
-                f2_new = f2 - self.excluded_faces # type: ignore
+            if self.included_faces is not None:
+                f1_new = f1 & self.included_faces # type: ignore
+                f2_new = f2 & self.included_faces # type: ignore
+            if len(f1_new.tags)==0:
+                continue
             bcs.append(Periodic(f1_new, f2_new, tuple(a)))
         self._bcs = bcs
         return bcs
@@ -191,16 +193,16 @@ class RectCell(PeriodicCell):
         return XYPlate(self.width, self.height, position=(0,0,z), alignment=Alignment.CENTER)
         
     def cell_data(self):
-        f1s = SELECTOR_OBJ.inplane(*self.fleft[0], *self.fleft[1])
-        f2s = SELECTOR_OBJ.inplane(*self.fright[0], *self.fright[1])
+        f1s = SELECTOR_OBJ.inplane(*self.fleft[0], self.fleft[1])
+        f2s = SELECTOR_OBJ.inplane(*self.fright[0], self.fright[1])
         vec = (self.fright[0][0]-self.fleft[0][0], 
                self.fright[0][1]-self.fleft[0][1], 
                self.fright[0][2]-self.fleft[0][2])
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)):
             yield f1, f2, vec
 
-        f1s = SELECTOR_OBJ.inplane(*self.fbot[0], *self.fbot[1])
-        f2s = SELECTOR_OBJ.inplane(*self.ftop[0], *self.ftop[1])
+        f1s = SELECTOR_OBJ.inplane(*self.fbot[0], self.fbot[1])
+        f2s = SELECTOR_OBJ.inplane(*self.ftop[0], self.ftop[1])
         vec = (self.ftop[0][0]-self.fbot[0][0], 
                self.ftop[0][1]-self.fbot[0][1], 
                self.ftop[0][2]-self.fbot[0][2])
@@ -273,9 +275,9 @@ class HexCell(PeriodicCell):
         o = self.o1[:-1]
         n = self.f11[1][:-1]
         w = nrm(self.p2-self.p1)/2
-        f1s = SELECTOR_OBJ.inplane(*self.f11[0], *self.f11[1])\
+        f1s = SELECTOR_OBJ.inplane(*self.f11[0], self.f11[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
-        f2s = SELECTOR_OBJ.inplane(*self.f12[0], *self.f12[1])\
+        f2s = SELECTOR_OBJ.inplane(*self.f12[0], self.f12[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
         vec = - (self.p1 + self.p2)
 
@@ -285,9 +287,9 @@ class HexCell(PeriodicCell):
         o = self.o2[:-1]
         n = self.f21[1][:-1]
         w = nrm(self.p3-self.p2)/2
-        f1s = SELECTOR_OBJ.inplane(*self.f21[0], *self.f21[1])\
+        f1s = SELECTOR_OBJ.inplane(*self.f21[0], self.f21[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
-        f2s = SELECTOR_OBJ.inplane(*self.f22[0], *self.f22[1])\
+        f2s = SELECTOR_OBJ.inplane(*self.f22[0], self.f22[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
         vec = - (self.p2 + self.p3)
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore
@@ -296,9 +298,9 @@ class HexCell(PeriodicCell):
         o = self.o3[:-1]
         n = self.f31[1][:-1]
         w = nrm(-self.p1-self.p3)/2
-        f1s = SELECTOR_OBJ.inplane(*self.f31[0], *self.f31[1])\
+        f1s = SELECTOR_OBJ.inplane(*self.f31[0], self.f31[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])-o)>w) or (abs((np.array([x,y])-o) @ n ) > 1e-6))
-        f2s = SELECTOR_OBJ.inplane(*self.f32[0], *self.f32[1])\
+        f2s = SELECTOR_OBJ.inplane(*self.f32[0], self.f32[1])\
             .exclude(lambda x, y, z: (nrm(np.array([x,y])+o)>w) or (abs((np.array([x,y])+o) @ n ) > 1e-6))
         vec = - (self.p3 - self.p1)
         for f1, f2 in zip(*_pair_selection(f1s, f2s, vec)): # type: ignore

emerge/_emerge/physics/microwave/assembly/assembler.py

@@ -22,6 +22,7 @@ from ....elements.nedleg2 import NedelecLegrange2
 from ....mth.optimized import gaus_quad_tri
 from ....mth.pairing import pair_coordinates
 from ....material import Material
+from ....settings import Settings
 from scipy.sparse import csr_matrix
 from loguru import logger
 from ..simjob import SimJob
@@ -102,13 +103,10 @@ class Assembler:
 
     It stores some cached properties to accellerate preformance.
     """
-    def __init__(self):
+    def __init__(self, settings: Settings):
         
         self.cached_matrices = None
-        self.conductivity_limit = 1e7
-        # Currently not used.
-        #self._Pmat_cache: dict[tuple[int,int], csr_matrix] = dict()
-        #self._remove_cache: list[int] = []
+        self.settings = settings
     
     def assemble_bma_matrices(self,
                               field: Nedelec2,
@@ -155,20 +153,22 @@ class Assembler:
         E, B = generelized_eigenvalue_matrix(nedlegfield, ermesh, urmesh, port.cs._basis, k0)
 
         # TODO: Simplified to all "conductors" loosely defined. Must change to implementing line robin boundary conditions.
-        pecs: list[BoundaryCondition] = bc_set.get_conductors()#[bc for bc in bcs if isinstance(bc,PEC)]
+        pecs: list[BoundaryCondition] = bc_set.get_conductors()
         if len(pecs) > 0:
-            logger.debug(f'.total of equiv. {len(pecs)} PEC BCs implemented')
+            logger.debug(f'.total of equiv. {len(pecs)} PEC BCs implemented for BMA')
 
         pec_ids = []
 
         # Process all concutors. Everything above the conductivity limit is considered pec.
         for it in range(boundary_surface.n_tris):
-            if sigmesh[it] > self.conductivity_limit:
+            if sigmesh[it] > self.settings.mw_3d_peclim:
                 pec_ids.extend(list(nedlegfield.tri_to_field[:,it]))
 
         # Process all PEC Boundary Conditions
         for pec in pecs:
             logger.trace(f'.implementing {pec}')
+            if len(pec.tags)==0:
+                continue
             face_tags = pec.tags
             tri_ids = mesh.get_triangles(face_tags)
             edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
@@ -235,7 +235,7 @@ class Assembler:
         
         er = er*(1-1j*tand) - 1j*cond/(W0*EPS0)
         
-        is_frequency_dependent = is_frequency_dependent or np.any((cond > 0) & (cond < self.conductivity_limit)) # type: ignore
+        is_frequency_dependent = is_frequency_dependent or np.any((cond > 0) & (cond < self.settings.mw_3d_peclim)) # type: ignore
 
         if cache_matrices and not is_frequency_dependent and self.cached_matrices is not None:
             # IF CACHED AND AVAILABLE PULL E AND B FROM CACHE
@@ -273,11 +273,11 @@ class Assembler:
         # Conductivity above al imit, consider it all PEC
         ipec = 0
         for itet in range(field.n_tets):
-            if cond[0,0,itet] > self.conductivity_limit:
+            if cond[0,0,itet] > self.settings.mw_3d_peclim:
                 ipec+=1
                 pec_ids.extend(field.tet_to_field[:,itet])
         if ipec>0:
-            logger.trace(f'Extended PEC with {ipec} tets with a conductivity > {self.conductivity_limit}.')
+            logger.trace(f'Extended PEC with {ipec} tets with a conductivity > {self.settings.mw_3d_peclim}.')
 
         for pec in pec_bcs:
             logger.trace(f'Implementing: {pec}')
@@ -466,7 +466,7 @@ class Assembler:
         
         # Conductivity above a limit, consider it all PEC
         for itet in range(field.n_tets):
-            if cond[0,0,itet] > self.conductivity_limit:
+            if cond[0,0,itet] > self.settings.mw_3d_peclim:
                 pec_ids.extend(field.tet_to_field[:,itet])
         
         # PEC Boundary conditions