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

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")

emerge/_emerge/mesh3d.py

@@ -28,6 +28,7 @@ from loguru import logger
 from functools import cache
 from .bc import Periodic
 from .mth.pairing import pair_coordinates
+from .material import Material
 
 @njit(f8(f8[:], f8[:], f8[:]), cache=True, nogil=True)
 def area(x1: np.ndarray, x2: np.ndarray, x3: np.ndarray):
@@ -538,10 +539,14 @@ class Mesh3D(Mesh):
         return conv_map, np.array(node_ids_2_unsorted), np.array(node_ids_2_sorted)
 
 
-    def retreive(self, material_selector: Callable, volumes: list[GeoVolume]) -> np.ndarray:
+    def retreive(self, volumes: list[GeoVolume]) -> list[Material]:
         '''Retrieve the material properties of the geometry'''
-        arry = np.zeros((3,3,self.n_tets,), dtype=np.complex128)
-
+        #arry = np.zeros((3,3,self.n_tets,), dtype=np.complex128)
+        for vol in volumes:
+            vol.material.reset()
+            
+        materials = []
+        
         xs = self.centers[0,:]
         ys = self.centers[1,:]
         zs = self.centers[2,:]
@@ -551,11 +556,12 @@ class Mesh3D(Mesh):
             for dimtag in volume.dimtags:
                 etype, etag_list, ntags = gmsh.model.mesh.get_elements(*dimtag)
                 for etags in etag_list:
-                    tet_ids = [self.tet_t2i[t] for t in etags]
-
-                    value = material_selector(volume.material, xs[tet_ids], ys[tet_ids], zs[tet_ids])
-                    arry[:,:,tet_ids] = value
-        return arry
+                    tet_ids = np.array([self.tet_t2i[t] for t in etags])
+                    volume.material.initialize(xs[tet_ids], ys[tet_ids], zs[tet_ids], tet_ids)
+                    if volume.material not in materials:
+                        materials.append(volume.material)
+        
+        return materials
     
     def plot_gmsh(self) -> None:
         gmsh.fltk.run()

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

@@ -21,7 +21,7 @@ from ....elements.nedelec2 import Nedelec2
 from ....elements.nedleg2 import NedelecLegrange2
 from ....mth.optimized import gaus_quad_tri
 from ....mth.pairing import pair_coordinates
-
+from ....material import Material
 from scipy.sparse import csr_matrix
 from loguru import logger
 from ..simjob import SimJob
@@ -188,9 +188,7 @@ class Assembler:
         return E, B, np.array(solve_ids), nedlegfield
 
     def assemble_freq_matrix(self, field: Nedelec2, 
-                        er: np.ndarray, 
-                        ur: np.ndarray, 
-                        sig: np.ndarray,
+                        materials: list[Material],
                         bcs: list[BoundaryCondition],
                         frequency: float,
                         cache_matrices: bool = False) -> SimJob:
@@ -215,11 +213,29 @@ class Assembler:
         # PREDEFINE CONSTANTS
         W0 = 2*np.pi*frequency
         K0 = W0/C0
-
+        
+        is_frequency_dependent = False
         mesh = field.mesh
-        er = er - 1j*sig/(W0*EPS0)*np.repeat(np.eye(3)[:, :, np.newaxis], er.shape[2], axis=2)
-        is_frequency_dependent: bool = np.any((sig > 0) & (sig < self.conductivity_limit)) # type: ignore
+
+        for mat in materials:
+            if mat.frequency_dependent:
+                is_frequency_dependent = True
+                break
+
+        er = np.zeros((3,3,field.mesh.n_tets), dtype=np.complex128)
+        tand = np.zeros((3,3,field.mesh.n_tets), dtype=np.complex128)
+        cond = np.zeros((3,3,field.mesh.n_tets), dtype=np.complex128)
+        ur = np.zeros((3,3,field.mesh.n_tets), dtype=np.complex128)
+        
+        for mat in materials:
+            er = mat.er(frequency, er)
+            ur = mat.ur(frequency, ur)
+            tand = mat.tand(frequency, tand)
+            cond = mat.cond(frequency, cond)
         
+        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
 
         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
@@ -253,10 +269,11 @@ class Assembler:
 
         logger.debug('Implementing PEC Boundary Conditions.')
         pec_ids: list[int] = []
+        
         # Conductivity above al imit, consider it all PEC
         ipec = 0
         for itet in range(field.n_tets):
-            if sig[itet] > self.conductivity_limit:
+            if cond[0,0,itet] > self.conductivity_limit:
                 ipec+=1
                 pec_ids.extend(field.tet_to_field[:,itet])
         if ipec>0:
@@ -388,12 +405,10 @@ class Assembler:
             simjob.Pd = Pmat.getH()
             simjob.has_periodic = has_periodic
 
-        return simjob
+        return simjob, (er, ur, cond)
     
     def assemble_eig_matrix(self, field: Nedelec2, 
-                        er: np.ndarray, 
-                        ur: np.ndarray, 
-                        sig: np.ndarray,
+                        materials: list[Material],
                         bcs: list[BoundaryCondition],
                         frequency: float) -> SimJob:
         """Assembles the eigenmode analysis matrix
@@ -420,9 +435,21 @@ class Assembler:
         w0 = 2*np.pi*frequency
         k0 = w0/C0
 
-        er = er - 1j*sig/(w0*EPS0)*np.repeat(np.eye(3)[:, :, np.newaxis], er.shape[2], axis=2)
+        er = np.zeros((3,3,field.mesh.n_tets), dtype=np.complex128)
+        tand = np.zeros((3,3,field.mesh.n_tets), dtype=np.complex128)
+        cond = np.zeros((3,3,field.mesh.n_tets), dtype=np.complex128)
+        ur = np.zeros((3,3,field.mesh.n_tets), dtype=np.complex128)
+        
+        for mat in materials:
+            er = mat.er(frequency, er)
+            ur = mat.ur(frequency, ur)
+            tand = mat.tand(frequency, tand)
+            cond = mat.cond(frequency, cond)
+        
+        er = er*(1-1j*tand) - 1j*cond/(w0*EPS0)
         
         logger.debug('Assembling matrices')
+        
         E, B = tet_mass_stiffness_matrices(field, er, ur)
         self.cached_matrices = (E, B)
 
@@ -439,7 +466,7 @@ class Assembler:
         
         # Conductivity above a limit, consider it all PEC
         for itet in range(field.n_tets):
-            if sig[itet] > self.conductivity_limit:
+            if cond[0,0,itet] > self.conductivity_limit:
                 pec_ids.extend(field.tet_to_field[:,itet])
         
         # PEC Boundary conditions
@@ -461,11 +488,7 @@ class Assembler:
         # Robin BCs
         if len(robin_bcs) > 0:
             logger.debug('Implementing Robin Boundary Conditions.')
-        
-        if len(robin_bcs) > 0:
-            logger.debug('Implementing Robin Boundary Conditions.')
-        
-            gauss_points = gaus_quad_tri(4)
+            
             Bempty = field.empty_tri_matrix()
             for bc in robin_bcs:
 
@@ -550,4 +573,4 @@ class Assembler:
             simjob.Pd = Pmat.getH()
             simjob.has_periodic = has_periodic
 
-        return simjob
+        return simjob, (er, ur, cond)