emerge 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

emerge/_emerge/geo/shapes.py

@@ -30,6 +30,7 @@ class Alignment(Enum):
     CENTER = 1
     CORNER = 2
 
+
 class Box(GeoVolume):
     """Creates a box volume object.
         Specify the alignment of the box with the provided position. The options are CORNER (default)
@@ -100,7 +101,7 @@ class Box(GeoVolume):
         
         tags = list(reduce(lambda a,b: a+b, tagslist))
         return FaceSelection(tags)
-
+    
     
 class Sphere(GeoVolume):
     """Generates a sphere objected centered ont he position with the given radius
@@ -122,6 +123,7 @@ class Sphere(GeoVolume):
         x,y,z = position
         self.tags: list[int] = [gmsh.model.occ.addSphere(x,y,z,radius),]
 
+
 class XYPlate(GeoSurface):
     """Generates and XY-plane oriented plate
         
@@ -209,27 +211,43 @@ class Plate(GeoSurface):
         tags: list[int] = [gmsh.model.occ.addPlaneSurface([tag_wire,]),]
         super().__init__(tags)
 
+
 class Cylinder(GeoVolume):
+    """Generates a Cylinder object in 3D space.
+        The cylinder will always be placed in the origin of the provided CoordinateSystem.
+        The bottom cylinder plane is always placed in the XY-plane. The length of the cylinder is
+        oriented along the Z-axis.
 
+        By default the cylinder uses the Open Cascade modeling for a cylinder. In this representation
+        the surface of the cylinder is approximated with a tolerance thay may be irregular.
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
+        by an extrusion of a regular N-sided polygon.
+
+        Args:
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
+            cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
+            Nsections (int, optional): The number of sections. Defaults to None.
+        """
     def __init__(self, 
                  radius: float,
                  height: float,
-                 cs: CoordinateSystem = None,
-                 Nsections: int = None):
+                 cs: CoordinateSystem = GCS,
+                 Nsections: int | None = None):
         """Generates a Cylinder object in 3D space.
-        The cyllinder will always be placed in the origin of the provided CoordinateSystem.
-        The bottom cyllinder plane is always placed in the XY-plane. The lenth of the cyllinder is
+        The cylinder will always be placed in the origin of the provided CoordinateSystem.
+        The bottom cylinder plane is always placed in the XY-plane. The length of the cylinder is
         oriented along the Z-axis.
 
-        By default the cyllinder uses the Open Cascade modeling for a cyllinder. In this representation
-        the surface of the cyllinder is approximated with a tolerance thay may be irregular.
+        By default the cylinder uses the Open Cascade modeling for a cylinder. In this representation
+        the surface of the cylinder is approximated with a tolerance thay may be irregular.
         As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
             radius (float): The radius of the Cylinder
             height (float): The height of the Cylinder
-            cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
+            cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
         ax = cs.zax.np
@@ -270,33 +288,46 @@ class Cylinder(GeoVolume):
         xo, yo, zo = self.cs.in_global_cs(x.flatten(), y.flatten(), z.flatten())
         return xo, yo, zo
 
+
 class CoaxCylinder(GeoVolume):
-    """A coaxial cylinder with an inner and outer radius."""
-    
+    """Generates a Coaxial cylinder object in 3D space.
+        The coaxial cylinder will always be placed in the origin of the provided CoordinateSystem.
+        The bottom coax plane is always placed in the XY-plane. The lenth of the coax is
+        oriented along the Z-axis.
+
+        By default the coax uses the Open Cascade modeling for a cylinder. In this representation
+        the surface of the cylinder is approximated with a tolerance thay may be irregular.
+        As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
+        by an extrusion of a regular N-sided polygon.
+
+        Args:
+            radius (float): The radius of the Cylinder
+            height (float): The height of the Cylinder
+            cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
+            Nsections (int, optional): The number of sections. Defaults to None.
+        """
     def __init__(self, 
                  rout: float,
                  rin: float,
                  height: float,
-                 cs: CoordinateSystem = None,
-                 Nsections: int = None):
-        """Generates a Coaxial cyllinder object in 3D space.
-        The coaxial cyllinder will always be placed in the origin of the provided CoordinateSystem.
+                 cs: CoordinateSystem = GCS,
+                 Nsections: int | None = None):
+        """Generates a Coaxial cylinder object in 3D space.
+        The coaxial cylinder will always be placed in the origin of the provided CoordinateSystem.
         The bottom coax plane is always placed in the XY-plane. The lenth of the coax is
         oriented along the Z-axis.
 
-        By default the coax uses the Open Cascade modeling for a cyllinder. In this representation
-        the surface of the cyllinder is approximated with a tolerance thay may be irregular.
+        By default the coax uses the Open Cascade modeling for a cylinder. In this representation
+        the surface of the cylinder is approximated with a tolerance thay may be irregular.
         As an alternative, the argument Nsections may be provided in which case the Cylinder is replaced
         by an extrusion of a regular N-sided polygon.
 
         Args:
             radius (float): The radius of the Cylinder
             height (float): The height of the Cylinder
-            cs (CoordinateSystem, optional): The coordinate system. Defaults to None.
+            cs (CoordinateSystem, optional): The coordinate system. Defaults to GCS.
             Nsections (int, optional): The number of sections. Defaults to None.
         """
-        if cs is None:
-            cs = GCS
         if rout <= rin:
             raise ValueError("Outer radius must be greater than inner radius.")
         
@@ -336,7 +367,7 @@ class CoaxCylinder(GeoVolume):
         return xo, yo, zo
     
 class HalfSphere(GeoVolume):
-
+    """A half sphere volume."""
     def __init__(self,
                  radius: float,
                  position: tuple = (0,0,0),
@@ -362,8 +393,6 @@ class HalfSphere(GeoVolume):
         self._add_face_pointer('back',np.array(position), np.array(direction))
         self._add_face_pointer('bottom',np.array(position), np.array(direction))
         self._add_face_pointer('face',np.array(position), np.array(direction))
-        
-
 
 
 class OldBox(GeoVolume):
@@ -389,8 +418,6 @@ class OldBox(GeoVolume):
             alignment (Alignment, optional): Which point of the box is placed at the position. 
                 Defaults to Alignment.CORNER.
         """
-        
-
         if alignment is Alignment.CORNER:
             position = (position[0]+width/2, position[1]+depth/2, position[2])
         elif alignment is Alignment.CENTER:
@@ -472,7 +499,6 @@ class OldBox(GeoVolume):
         self._add_face_pointer('right', pc + width/2*wax, wax)
         self._add_face_pointer('top', pc + height/2*hax, hax)
         self._add_face_pointer('bottom', pc - height/2*hax, -hax)
-        
     
     def outside(self, *exclude: Literal['bottom','top','right','left','front','back']) -> FaceSelection:
         """Select all outside faces except for the once specified by outside
@@ -485,8 +511,17 @@ class OldBox(GeoVolume):
         tags = list(reduce(lambda a,b: a+b, tagslist))
         return FaceSelection(tags)
 
+
 class Cone(GeoVolume):
-    
+    """Constructis a cone that starts at position p0 and is aimed in the given direction.
+        r1 is the start radius and r2 the end radius. The magnitude of direction determines its length.
+
+        Args:
+            p0 (tuple[float, float, float]): _description_
+            direction (tuple[float, float, float]): _description_
+            r1 (float): _description_
+            r2 (float): _description_
+        """
     def __init__(self, p0: tuple[float, float, float],
                  direction: tuple[float, float, float],
                  r1: float,

emerge/_emerge/geometry.py

@@ -376,7 +376,7 @@ class GeoObject:
         return self
     
     def prio_up(self) -> GeoObject:
-        """Increase priority by 1
+        """Increases the material selection priority by 1
 
         Returns:
             GeoObject: _description_
@@ -385,7 +385,7 @@ class GeoObject:
         return self
     
     def prio_down(self) -> GeoObject:
-        """Decrase priority by 1
+        """Decreases the material selection priority by 1
 
         Returns:
             GeoObject: _description_
@@ -394,7 +394,7 @@ class GeoObject:
         return self
 
     def background(self) -> GeoObject:
-        """Set the priority to be on the background.
+        """Set the material selection priority to be on the background.
 
         Returns:
             GeoObject: _description_
@@ -403,7 +403,7 @@ class GeoObject:
         return self
 
     def foreground(self) -> GeoObject:
-        """Set the priority to be on top.
+        """Set the material selection priority to be on top.
 
         Returns:
             GeoObject: _description_

emerge/_emerge/material.py

@@ -16,108 +16,353 @@
 # <https://www.gnu.org/licenses/>.
 
 import numpy as np
-from dataclasses import dataclass
 from typing import Callable
+import inspect
+
+
+def num_args(func):
+    sig = inspect.signature(func)
+    return sum(
+        1
+        for p in sig.parameters.values()
+        if p.default is inspect._empty and p.kind in (
+            p.POSITIONAL_ONLY,
+            p.POSITIONAL_OR_KEYWORD,
+            p.KEYWORD_ONLY
+        )
+    )
+    
+def _to_mat(value: float | complex | int | np.ndarray) -> np.ndarray:
+    if np.isscalar(value):
+        return np.eye(3)*value
+    if value.shape in ((3,), (3,1), (1,3)):
+        return np.diag(np.ravel(value))
+    if value.shape == (3,3):
+        return value
+    else:
+        return ValueError(f'Trying to parse {value} as a material property tensor but it cant be identified as scalar, vector or matrix')
+
+class MatProperty:
+    _freq_dependent: bool = False
+    _coord_dependent: bool = False
+    """The MatProperty class is an interface for EMerge to deal with frequency and coordinate dependent material properties
+    """
+
+    def __init__(self, value: float | complex | int | np.ndarray):
+        self.value: np.ndarray = _to_mat(value)
+        
+        self._apply_to: np.ndarray = np.array([], dtype=np.int64)
+        self._x: np.ndarray = np.array([], dtype=np.float64)
+        self._y: np.ndarray = np.array([], dtype=np.float64)
+        self._z: np.ndarray = np.array([], dtype=np.float64)
+        
+        self._fmax = lambda f: value
+
+    def initialize(self, x: np.ndarray, y: np.ndarray, z: np.ndarray, ids: np.ndarray) -> None:
+        self._apply_to = np.concatenate([self._apply_to, ids])
+        self._x = np.concatenate([self._x, x])
+        self._y = np.concatenate([self._y, y])
+        self._z = np.concatenate([self._z, z])
+        
+    def __call__(self, f: float, data: np.ndarray) -> np.ndarray:
+        data[:,:,self._apply_to] = np.repeat(self.value[:,:,np.newaxis], self._apply_to.shape[0], axis=2)
+        return data
+
+    def scalar(self, f: float):
+        return self.value[0,0]
+
+    def reset(self) -> None:
+        self._apply_to: np.ndarray = np.array([], dtype=np.int64)
+        self._x: np.ndarray = np.array([], dtype=np.float64)
+        self._y: np.ndarray = np.array([], dtype=np.float64)
+        self._z: np.ndarray = np.array([], dtype=np.float64)
+        
+class FreqDependent(MatProperty):
+    _freq_dependent: bool = True
+    _coord_dependent: bool = False
+
+    def __init__(self, 
+                 scalar: Callable | None = None,
+                 vector: Callable | None = None,
+                 matrix: Callable | None = None):
+        """Creates a frequency dependent property object.
+        
+        If the property is defined as a scalar value, use the "scalar" argument
+        If the property is a diagonal rank-2 tensor, use the "vector" argument                   
+        If the property is a full rank-2 tensor, use the "matrix" argument
+
+        The max_value property must be set to tell EMerge how height this value can get 
+        as it will be used to define the discretization of the mesh.
+        
+        Args:
+            scalar (Callable | None, optional): The scalar value function returning a float/complex. Defaults to None.
+            vector (Callable | None, optional): The diagonal rank-2 tensor function returning a (3,) array. Defaults to None.
+            matrix (Callable | None, optional): The rank-2 tensor function returning a (3,3) array. Defaults to None.
+
+        Returns:
+            _type_: _description_
+        """
+        if scalar is not None:
+            def _func(f: float) -> np.ndarray:
+                return np.eye(3)*scalar(f)
+        if vector is not None:
+            def _func(f: float) -> np.ndarray:
+                return np.diag(np.ravel(vector(f)))
+        
+        if matrix is not None:
+            _func = matrix
+
+        self._func: Callable = _func
+        
+        self._apply_to: np.ndarray = np.array([], dtype=np.int64)
+        self._x: np.ndarray = np.array([], dtype=np.float64)
+        self._y: np.ndarray = np.array([], dtype=np.float64)
+        self._z: np.ndarray = np.array([], dtype=np.float64)
+        
+        self._fmax: Callable = lambda f: np.max(np.ravel(self._func(f)))
+
+    def initialize(self, x: np.ndarray, y: np.ndarray, z: np.ndarray, ids: np.ndarray) -> None:
+        self._apply_to = np.concatenate([self._apply_to, ids])
+        
+    def __call__(self, f: float, data: np.ndarray) -> np.ndarray:
+        data[:,:,self._apply_to] = np.repeat(self._func(f)[:,:,np.newaxis], self._apply_to.shape[0], axis=2)
+        return data
+    
+    def scalar(self, f: float):
+        return self._func(f)[0,0]
+    
+class CoordDependent(MatProperty):
+    _freq_dependent: bool = False
+    _coord_dependent: bool = True
+    def __init__(self, 
+                 max_value: float,
+                 scalar: Callable | None = None,
+                 vector: Callable | None = None,
+                 matrix: Callable | None = None,
+                 ):
+        """Creates a coordinate dependent property object.
+        
+        If the property is defined as a scalar value, use the "scalar" argument.
+        
+        If the property is a diagonal rank-2 tensor, use the "vector" argument.
+        
+        If the property is a full rank-2 tensor, use the "matrix" argument.
+        
+
+        The max_value property must be set to tell EMerge how height this value can get 
+        as it will be used to define the discretization of the mesh.
+        
+        Args:
+            max_value (float): The heighest value of the material property
+            scalar (Callable | None, optional): The scalar value function returning a float/complex. Defaults to None.
+            vector (Callable | None, optional): The diagonal rank-2 tensor function returning a (3,) array. Defaults to None.
+            matrix (Callable | None, optional): The rank-2 tensor function returning a (3,3) array. Defaults to None.
+
+        Returns:
+            _type_: _description_
+        """
+        
+        if scalar is not None:
+            def _func(x, y, z) -> np.ndarray:
+                return np.eye(3)[:, :, None] * scalar(x,y,z)[None, None, :]
+        if vector is not None:
+            def _func(x, y, z) -> np.ndarray:
+                N = x.shape[0]
+                out = np.zeros((3, 3, N), dtype=vector(0,0,0).dtype)
+                idx = np.arange(3)
+                out[idx, idx, :] = vector(x,y,z)
+                return out
+        if matrix is not None:
+            _func = matrix
+
+        self._func: Callable = _func
+        self._apply_to: np.ndarray = np.array([], dtype=np.int64)
+        self._x: np.ndarray = np.array([], dtype=np.float64)
+        self._y: np.ndarray = np.array([], dtype=np.float64)
+        self._z: np.ndarray = np.array([], dtype=np.float64)
+        
+        self._values: np.ndarray = None
+        self._fmax: Callable = lambda f: max_value
+
+    def initialize(self, x: np.ndarray, y: np.ndarray, z: np.ndarray, ids: np.ndarray) -> None:
+        self._apply_to = np.concatenate([self._apply_to, ids])
+        self._x = np.concatenate([self._x, x])
+        self._y = np.concatenate([self._y, y])
+        self._z = np.concatenate([self._z, z])
+        
+    def __call__(self, f: float, data: np.ndarray) -> np.ndarray:
+        data[:,:,self._apply_to] = self._func(self._x, self._y, self._z)
+        return data
+
+    def scalar(self, f: float):
+        return self._func(0,0,0)[0,0]
+    
+class FreqCoordDependent(MatProperty):
+    _freq_dependent: bool = True
+    _coord_dependent: bool = True
+    
+    def __init__(self, 
+                 max_value: float,
+                 scalar: Callable | None = None,
+                 vector: Callable | None = None,
+                 matrix: Callable | None = None):
+        """Creates a frequency and coordinate dependent property object.
+        
+        If the property is defined as a scalar value, use the "scalar" argument.
+        
+        If the property is a diagonal rank-2 tensor, use the "vector" argument.
+        
+        If the property is a full rank-2 tensor, use the "matrix" argument.
+
+        The max_value property must be set to tell EMerge how height this value can get 
+        as it will be used to define the discretization of the mesh.
+        
+        Args:
+            max_value (float): The heighest value of the material property
+            scalar (Callable | None, optional): The scalar value function returning a float/complex. Defaults to None.
+            vector (Callable | None, optional): The diagonal rank-2 tensor function returning a (3,) array. Defaults to None.
+            matrix (Callable | None, optional): The rank-2 tensor function returning a (3,3) array. Defaults to None.
+
+        Returns:
+            _type_: _description_
+        """
+        if scalar is not None:
+            def _func(f, x, y, z) -> np.ndarray:
+                return np.eye(3)[:, :, None] * scalar(f,x,y,z)[None, None, :]
+        if vector is not None:
+            def _func(f,x, y, z) -> np.ndarray:
+                N = x.shape[0]
+                out = np.zeros((3, 3, N), dtype=vector(1e9,0,0,0).dtype)
+                idx = np.arange(3)
+                out[idx, idx, :] = vector(f,x,y,z)
+                return out
+        if matrix is not None:
+            _func = matrix
+
+        self._func: Callable = _func
+        
+        self._apply_to: np.ndarray = np.array([], dtype=np.int64)
+        self._x: np.ndarray = np.array([], dtype=np.float64)
+        self._y: np.ndarray = np.array([], dtype=np.float64)
+        self._z: np.ndarray = np.array([], dtype=np.float64)
+        
+        self._fmax: Callable = lambda f: max_value
+
+    def initialize(self, x: np.ndarray, y: np.ndarray, z: np.ndarray, ids: np.ndarray) -> None:
+        self._apply_to = np.concatenate([self._apply_to, ids])
+        self._x = np.concatenate([self._x, x])
+        self._y = np.concatenate([self._y, y])
+        self._z = np.concatenate([self._z, z])
+        
+    def __call__(self, f: float, data: np.ndarray) -> np.ndarray:
+        data[:,:,self._apply_to] = self._func(f,self._x, self._y,self._z)
+        return data
+    
+    def scalar(self, f: float):
+        return self._func(f, 0,0,0)[0,0]
+
+# To be finished once its clear how to deal with default values for functions
+
+# def parse_material_property(value: complex | float | Callable):
+#     if not isinstance(value, Callable):
+#         return MatProperty(value)
+#     pass
 
-@dataclass
 class Material:
     """The Material class generalizes a material in the EMerge FEM environment.
 
     If a scalar value is provided for the relative permittivity or the relative permeability
     it will be used as multiplication entries for the material property diadic as identity matrix.
 
-    Additionally, a function may be provided that computes a coordinate dependent material property
-    for _fer. For example: Material(_fer = lambda x,y,z: ...). 
-    The x,y and z coordinates are provided as a (N,) np.ndarray. The return array must be of shape (3,3,N)!
+    Additionally, a frequency, coordinate or both frequency and coordinate dependent material property
+    may be supplied for the properties: er, ur, tand and cond.
+    
+    To supply a frequency-dependent property use: emerge.FreqDependent()
+    To supply a coordinate-dependent property use: emerge.CoordDependent()
+    to supply a frequency and coordinate dependent property use: emerge.FreqCoordDependent()
     
     """
-    er: float = 1
-    ur: float = 1
-    tand: float = 0
-    cond: float = 0
-    _neff: float | None = None
-    _fer: Callable | None= None
-    _fur: Callable | None = None
-    color: str = "#BEBEBE"
-    _color_rgb: tuple[float,float,float] = (0.5, 0.5, 0.5)
-    opacity: float = 1.0
-
-    def __post_init__(self):
-        hex_str = self.color.lstrip('#')
-        self._color_rgb = tuple(int(hex_str[i:i+2], 16)/255.0 for i in (0, 2, 4))
-
-    @property
-    def sigma(self) -> float:
-        return self.cond
+    def __init__(self,
+                 er: float | complex | np.ndarray | MatProperty = 1.0,
+                 ur: float | complex | np.ndarray | MatProperty = 1.0,
+                 tand: float | MatProperty = 0.0,
+                 cond: float | MatProperty = 0.0,
+                 _neff: float | None = None,
+                 color: str ="#BEBEBE",
+                 opacity: float = 1.0):
         
-    @property
-    def color_rgb(self) -> tuple[float,float,float]:
-        return self._color_rgb
-    
-    @property
-    def ermat(self) -> np.ndarray:
-        if isinstance(self.er, (float, complex, int, np.float64, np.complex128)):
-            return self.er*(1-1j*self.tand)*np.eye(3)
-        else:
-            return self.er*(1-1j*self.tand)
-    
-    @property
-    def urmat(self) -> np.ndarray:
-        if isinstance(self.ur, (float, complex, int, np.float64, np.complex128)):
-            return self.ur*np.eye(3)
+        if not isinstance(er, MatProperty):
+            er = MatProperty(er)
+        if not isinstance(ur, MatProperty):
+            ur = MatProperty(ur)
+        if not isinstance(tand, MatProperty):
+            tand = MatProperty(tand)
+        if not isinstance(cond, MatProperty):
+            cond = MatProperty(cond)
+        
+        self.er: MatProperty = er
+        self.ur: MatProperty = ur
+        self.tand: MatProperty = tand
+        self.cond: MatProperty = cond
+
+        self.color: str = color
+        self.opacity: float = opacity
+        if _neff is None:
+            self._neff: Callable = lambda f: np.sqrt(self.ur._fmax(f)*self.er._fmax(f))
         else:
-            return self.ur
+            self._neff: Callable = lambda f: _neff
+        hex_str = self.color.lstrip('#')
+        self._color_rgb = tuple(int(hex_str[i:i+2], 16)/255.0 for i in (0, 2, 4))
     
-    @property
-    def neff(self) -> complex:
-        if self._neff is not None:
-            return self._neff
-        er = self.ermat[0,0]
-        ur = self.urmat[0,0]
+    def initialize(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, ids: np.ndarray):
+        """Initializes the Material properties to be evaluated at xyz-coordinates for
+        a given set of tetrahedral ids.
 
-        return np.abs(np.sqrt(er*(1-1j*self.tand)*ur))
+        Args:
+            xs (np.ndarray): The tet-centroid x-coordinates
+            ys (np.ndarray): The tet-centroid y-coordinates
+            zs (np.ndarray): The tet-centroid z-coordinates
+            ids (np.ndarray): The tet-indices
+        """
+        self.er.initialize(xs, ys, zs, ids)
+        self.ur.initialize(xs, ys, zs, ids)
+        self.tand.initialize(xs, ys, zs, ids)
+        self.cond.initialize(xs, ys, zs, ids)
     
-    @property
-    def fer2d(self) -> Callable:
-        if self._fer is None:
-            return lambda x,y: self.er*(1-1j*self.tand)*np.ones_like(x)
-        else:
-            return self._fer
+    def reset(self) -> None:
+        """Resets assignment of material properties to coordiantes and tetrahedral indices.
+        """
+        self.er.reset()
+        self.ur.reset()
+        self.tand.reset()
+        self.cond.reset()
         
     @property
-    def fur2d(self) -> Callable:
-        if self._fur is None:
+    def frequency_dependent(self) -> bool:
+        """If The material property are at all frequency dependent.
 
-            return lambda x,y: self.ur*np.ones_like(x)
-        else:
-            return self._fur
-    @property
-    def fer3d(self) -> Callable:
-        if self._fer is None:
-            return lambda x,y,z: self.er*(1-1j*self.tand)*np.ones_like(x)
-        else:
-            return self._fer
+        Returns:
+            bool: _description_
+        """
+        return self.er._freq_dependent or self.ur._freq_dependent or self.tand._freq_dependent or self.cond._freq_dependent
     
     @property
-    def fur3d(self) -> Callable:
-        if self._fur is None:
-            return lambda x,y,z: self.ur*np.ones_like(x)
-        else:
-            return self._fur
-    @property
-    def fer3d_mat(self) -> Callable:
-        if self._fer is None:
-            
-            return lambda x,y,z: np.repeat(self.ermat[:, :, np.newaxis], x.shape[0], axis=2)
-        else:
-            return self._fer
+    def coordinate_dependent(self) -> bool:
+        """If the material properties are at all coordinate dependent
+
+        Returns:
+            bool: _description_
+        """
+        return self.er._coord_dependent or self.ur._coord_dependent or self.tand._coord_dependent or self.cond._coord_dependent
+    
+    
+    def neff(self, f: float):
+        """ Computes the maximum occuring effective refractive index for this material."""
+        return self._neff(f)
     
     @property
-    def fur3d_mat(self) -> Callable:
-        if self._fur is None:
-            return lambda x,y,z: np.repeat(self.urmat[:, :, np.newaxis], x.shape[0], axis=2)
-        else:
-            return self._fur
-        
+    def color_rgb(self) -> tuple[float,float,float]:
+        return self._color_rgb
+     
 AIR = Material(color="#4496f3", opacity=0.05)
 COPPER = Material(cond=5.8e7, color="#62290c")