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

emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.8"
+__version__ = "0.6.10"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #
@@ -43,12 +43,13 @@ from loguru import logger
 
 LOG_CONTROLLER.set_default()
 logger.debug('Importing modules')
+LOG_CONTROLLER._set_log_buffer()
 
 from ._emerge.simmodel import Simulation
 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
+from ._emerge.cs import CoordinateSystem, CS, GCS, Plane, Axis, XAX, YAX, ZAX, XYPLANE, XZPLANE, YZPLANE, YXPLANE, ZXPLANE, ZYPLANE, cs
 from ._emerge.coord import Line
 from ._emerge import geo
 from ._emerge.selection import Selection, FaceSelection, DomainSelection, EdgeSelection
@@ -62,4 +63,12 @@ from ._emerge.howto import _HowtoClass
 
 howto = _HowtoClass()
 
-logger.debug('Importing complete!')
+logger.debug('Importing complete!')
+
+
+############################################################
+#                         CONSTANTS                        #
+############################################################
+
+CENTER = geo.Alignment.CENTER
+CORNER = geo.Alignment.CORNER

emerge/_emerge/cs.py

@@ -530,3 +530,39 @@ CS = CoordinateSystem
 # The global coordinate system
 GCS = CoordinateSystem(XAX, YAX, ZAX, np.zeros(3), _is_global=True)
 
+def cs(axes: str, origin: tuple[float, float, float] = (0.,0.,0.,)) -> CoordinateSystem:
+    """Generate a coordinate system based on a simple string
+    The string must contain the letters x, X, y, Y, z and/or Z. 
+    Small letters refer to positive axes and capitals to negative axes.
+    
+    The string must be 3 characters long.
+    
+    The first position indices which global axis gets assigned to the new local X-axis
+    The second position indicates the Y-axis
+    The third position indicates the Z-axis
+    
+    Thus, rotating the global XYZ coordinate system 90 degrees around the Z axis would yield: yXz
+
+    Args:
+        axes (str): The axis description
+        origin (tuple[float, float, float], optional): The origin of the coordinate system. Defaults to (0.,0.,0.,).
+
+    Returns:
+        CoordinateSystem: The resultant coordinate system
+    """
+    if len(axes) != 3:
+        raise ValueError('Axis object must be of length 3')
+    
+    axlib = {
+        'x': Axis(np.array([1.0,0.,0.])),
+        'X': Axis(np.array([-1.0,0.,0.])),
+        'y': Axis(np.array([0.,1.0,0.])),
+        'Y': Axis(np.array([0.,-1.0,0.])),
+        'z': Axis(np.array([0.,0.,1.0])),
+        'Z': Axis(np.array([0.,0.,-1.0])),
+    }
+    ax_obj = [axlib[ax] for ax in axes]
+    
+    return (ax_obj[0]*ax_obj[1]*ax_obj[2]).displace(*origin)
+
+

emerge/_emerge/geo/polybased.py

@@ -206,6 +206,7 @@ def orthonormalize(axis: np.ndarray) -> tuple[np.ndarray, np.ndarray, np.ndarray
     Zaxis = np.abs(Zaxis/np.linalg.norm(Zaxis))
     return Xaxis, Yaxis, Zaxis
 
+
 class GeoPrism(GeoVolume):
     """The GepPrism class generalizes the GeoVolume for extruded convex polygons.
     Besides having a volumetric definitions, the class offers a .front_face 
@@ -216,35 +217,65 @@ class GeoPrism(GeoVolume):
     """
     def __init__(self,
                  volume_tag: int,
-                 front_tag: int,
-                 side_tags: list[int],):
+                 front_tag: int | None = None,
+                 side_tags: list[int] | None = None,
+                 _axis: Axis | None = None):
         super().__init__(volume_tag)
-        self.front_tag: int = front_tag
-        self.back_tag: int = None
+        
+        
+        
+        if front_tag is not None and side_tags is not None:
+            self.front_tag: int = front_tag
+            self.back_tag: int = None
 
-        gmsh.model.occ.synchronize()
-        o1 = gmsh.model.occ.get_center_of_mass(2, self.front_tag)
-        n1 = gmsh.model.get_normal(self.front_tag, (0,0))
-        self._add_face_pointer('back', o1, n1)
+            gmsh.model.occ.synchronize()
+            self._add_face_pointer('back', tag=self.front_tag)
 
-        tags = gmsh.model.get_boundary(self.dimtags, oriented=False)
-        
-        for dim, tag in tags:
-            if (dim,tag) in side_tags:
-                continue
-            o2 = gmsh.model.occ.get_center_of_mass(2, tag)
-            n2 = gmsh.model.get_normal(tag, (0,0))
-            self._add_face_pointer('front', o2, n2)
-            self.back_tag = tag
-            break
+            tags = gmsh.model.get_boundary(self.dimtags, oriented=False)
+            
+            for dim, tag in tags:
+                if (dim,tag) in side_tags:
+                    continue
+                self._add_face_pointer('front',tag=tag)
+                self.back_tag = tag
+                break
 
-        self.side_tags: list[int] = [dt[1] for dt in tags if dt[1]!=self.front_tag and dt[1]!=self.back_tag]
+            self.side_tags: list[int] = [dt[1] for dt in tags if dt[1]!=self.front_tag and dt[1]!=self.back_tag]
 
-        for tag in self.side_tags:
-            o2 = gmsh.model.occ.get_center_of_mass(2, tag)
-            n2 = gmsh.model.get_normal(tag, (0,0))
-            self._add_face_pointer(f'side{tag}', o2, n2)
-            self.back_tag = tag
+            for tag in self.side_tags:
+    
+                self._add_face_pointer(f'side{tag}', tag=tag)
+                self.back_tag = tag
+                
+        elif _axis is not None:
+            _axis = _parse_axis(_axis)
+            gmsh.model.occ.synchronize()
+            tags = gmsh.model.get_boundary(self.dimtags, oriented=False)
+            faces = []
+            for dim, tag in tags:
+                o1 = np.array(gmsh.model.occ.get_center_of_mass(2, tag))
+                n1 = np.array(gmsh.model.get_normal(tag, (0,0)))
+                if abs(np.sum(n1*_axis.np)) > 0.99:
+                    dax = sum(o1 * _axis.np)
+                    faces.append((o1, n1, dax, tag))
+            
+            faces = sorted(faces, key=lambda x: x[2])
+            ftags = []
+            if len(faces) >= 2:
+                ftags.append(faces[0][3])
+                ftags.append(faces[-1][3])
+                self._add_face_pointer('front',faces[0][0], faces[0][1])
+                self._add_face_pointer('back', faces[-1][0], faces[-1][1])
+            elif len(faces)==1:
+                ftags.append(faces[0][3])
+                self._add_face_pointer('cap',faces[0][0], faces[0][1])
+            
+            ictr = 1
+            for dim, tag in tags:
+                if tag in ftags:
+                    continue
+                self._add_face_pointer(f'side{ictr}', tag=tag)
+                ictr += 1
 
     def outside(self, *exclude: Literal['front','back']) -> FaceSelection:
         """Select all outside faces except for the once specified by outside
@@ -462,9 +493,10 @@ class XYPolygon:
         ax, ay, az = axis
         
         volume = gmsh.model.occ.revolve(poly_fin.dimtags, x,y,z, ax, ay, az, angle*np.pi/180)
+        
         tags = [t for d,t in volume if d==3]
-        surftags = [t for d,t in volume if d==2]
-        return GeoPrism(tags, surftags[0], surftags)
+        poly_fin.remove()
+        return GeoPrism(tags, _axis=axis)
 
     @staticmethod
     def circle(radius: float, 

emerge/_emerge/geo/shapes.py

@@ -27,6 +27,12 @@ from typing import Literal
 from functools import reduce
 
 class Alignment(Enum):
+    """The alignment Enum describes if a box, cube or rectangle location
+    is specified for the center or the bottom - front - left corner (min X Y and Z)
+
+    Args:
+        Enum (_type_): _description_
+    """
     CENTER = 1
     CORNER = 2
 

emerge/_emerge/geometry.py

@@ -61,8 +61,11 @@ class _GeometryManager:
         self.geometry_list[model].append(geo)
 
     def sign_in(self, modelname: str) -> None:
-        if modelname not in self.geometry_list:
-            self.geometry_list[modelname] = []
+        # 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.active = modelname
 
     def reset(self, modelname: str) -> None:
@@ -242,6 +245,10 @@ class GeoObject:
     def opacity(self) -> float:
         return self.material.opacity
     
+    @property
+    def _metal(self) -> bool:
+        return self.material._metal
+    
     @property
     def select(self) -> Selection:
         '''Returns a corresponding Face/Domain or Edge Selection object'''
@@ -278,9 +285,18 @@ class GeoObject:
     
     def _add_face_pointer(self, 
                           name: str,
-                          origin: np.ndarray,
-                          normal: np.ndarray):
-        self._face_pointers[name] = _FacePointer(origin, normal)
+                          origin: np.ndarray | None = None,
+                          normal: np.ndarray | None = None,
+                          tag: int | None = None):
+        if tag is not None:
+            o = gmsh.model.occ.get_center_of_mass(2, tag)
+            n = gmsh.model.get_normal(tag, (0,0))
+            self._face_pointers[name] = _FacePointer(o, n)
+            return
+        if origin is not None and normal is not None:
+            self._face_pointers[name] = _FacePointer(origin, normal)
+            return
+        raise ValueError('Eitehr a tag or an origin + normal must be provided!')
     
     def make_copy(self) -> GeoObject:
         new_dimtags = gmsh.model.occ.copy(self.dimtags)

emerge/_emerge/logsettings.py

@@ -18,11 +18,14 @@
 from loguru import logger
 import sys
 from typing import Literal
-from enum import Enum
 from pathlib import Path
 import os
-import gmsh
+from collections import deque
 
+_LOG_BUFFER = deque()
+
+def _log_sink(message):
+    _LOG_BUFFER.append(message)
 ############################################################
 #                          FORMATS                         #
 ############################################################
@@ -82,6 +85,14 @@ class LogController:
                 format=FORMAT_DICT.get(loglevel, INFO_FORMAT))
         self.std_handlers.append(handle_id)
 
+    def _set_log_buffer(self):
+        logger.add(_log_sink)
+        
+    def _flush_log_buffer(self):
+        for msg in list(_LOG_BUFFER):
+            logger.opt(depth=6).log(msg.record["level"].name, msg.record["message"])
+        _LOG_BUFFER.clear()
+        
     def set_std_loglevel(self, loglevel: str):
         handler = {"sink": sys.stdout, 
                    "level": loglevel, 

emerge/_emerge/material.py

@@ -289,7 +289,9 @@ class Material:
                  cond: float | MatProperty = 0.0,
                  _neff: float | None = None,
                  color: str ="#BEBEBE",
-                 opacity: float = 1.0):
+                 opacity: float = 1.0,
+                 _metal: bool = False,
+                 name: str = 'unnamed'):
         
         if not isinstance(er, MatProperty):
             er = MatProperty(er)
@@ -300,6 +302,7 @@ class Material:
         if not isinstance(cond, MatProperty):
             cond = MatProperty(cond)
         
+        self.name: str = name
         self.er: MatProperty = er
         self.ur: MatProperty = ur
         self.tand: MatProperty = tand
@@ -307,12 +310,24 @@ class Material:
 
         self.color: str = color
         self.opacity: float = opacity
+        self._hash_key: int = -1
+        
         if _neff is None:
             self._neff: Callable = lambda f: np.sqrt(self.ur._fmax(f)*self.er._fmax(f))
         else:
             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))
+        self._metal: bool = _metal
+
+    def __hash__(self):
+        return self._hash_key
+    
+    def __str__(self) -> str:
+        return f'Material({self.name}, {self._hash_key})'
+    
+    def __repr__(self):
+        return f'Material({self.name}, {self._hash_key})'
     
     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
@@ -336,6 +351,7 @@ class Material:
         self.ur.reset()
         self.tand.reset()
         self.cond.reset()
+        self._hash_key = -1
         
     @property
     def frequency_dependent(self) -> bool:
@@ -364,5 +380,5 @@ class Material:
     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")
+AIR = Material(color="#4496f3", opacity=0.05, name='Air')
+COPPER = Material(cond=5.8e7, color="#62290c", _metal=True, name='Copper')

emerge/_emerge/mesh3d.py

@@ -544,22 +544,33 @@ class Mesh3D(Mesh):
         #arry = np.zeros((3,3,self.n_tets,), dtype=np.complex128)
         for vol in volumes:
             vol.material.reset()
-            
+        
         materials = []
+        i = 0
+        for vol in volumes:
+            if vol.material not in materials:
+                materials.append(vol.material)
+                vol.material._hash_key = i
+                i += 1
         
         xs = self.centers[0,:]
         ys = self.centers[1,:]
         zs = self.centers[2,:]
         
+        matassign = -1*np.ones((self.n_tets,), dtype=np.int64)
+        
         for volume in sorted(volumes, key=lambda x: x._priority):
         
             for dimtag in volume.dimtags:
                 etype, etag_list, ntags = gmsh.model.mesh.get_elements(*dimtag)
                 for etags in etag_list:
                     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)
+                    matassign[tet_ids] = volume.material._hash_key
+        
+        for mat in materials:
+            ids = np.argwhere(matassign==mat._hash_key).flatten()
+            mat.initialize(xs[ids], ys[ids], zs[ids], ids)
+                    
         
         return materials
     

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -53,7 +53,7 @@ def run_job_multi(job: SimJob) -> SimJob:
     Returns:
         SimJob: The solved SimJob
     """
-    routine = DEFAULT_ROUTINE.duplicate()._configure_routine('MP')
+    routine = DEFAULT_ROUTINE._configure_routine('MP')
     for A, b, ids, reuse, aux in job.iter_Ab():
         solution, report = routine.solve(A, b, ids, reuse, id=job.id)
         report.add(**aux)

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -306,11 +306,17 @@ class AbsorbingBoundary(RobinBC):
         Returns:
             complex: The γ-constant
         """
-        return 1j*self.get_beta(k0)
+        if self.order == 2:
+            
+            p0 = 1.06103
+            p2 = -0.84883
+            ky = k0*0.5
+            return 1j*k0*p0 - 1j*p2*ky**2/k0
+        else:
+            Factor = 1
+            return 1j*self.get_beta(k0)*Factor
     
-    def get_Uinc(self, x_local: np.ndarray, y_local: np.ndarray, k0: float) -> np.ndarray:
-        return np.zeros((3, len(x_local)), dtype=np.complex128)
-
+   
 @dataclass
 class PortMode:
     modefield: np.ndarray
@@ -354,7 +360,7 @@ class FloquetPort(PortBC):
         if cs is None:
             cs = GCS
         self.port_number: int= port_number
-        self.active: bool = True
+        self.active: bool = False
         self.power: float = power
         self.type: str = 'TEM'
         self.mode: tuple[int,int] = (1,0)
@@ -439,7 +445,6 @@ class ModalPort(PortBC):
     def __init__(self,
                  face: FaceSelection | GeoSurface,
                  port_number: int, 
-                 active: bool = False,
                  cs: CoordinateSystem | None = None,
                  power: float = 1,
                  TEM: bool = False,
@@ -457,7 +462,6 @@ class ModalPort(PortBC):
         Args:
             face (FaceSelection, GeoSurface): The port mode face
             port_number (int): The port number as an integer
-            active (bool, optional): Whether the port is set active. Defaults to False.
             cs (CoordinateSystem, optional): The local coordinate system of the port face. Defaults to None.
             power (float, optional): The radiated power. Defaults to 1.
             TEM (bool, optional): Wether the mode should be considered as a TEM mode. Defaults to False
@@ -467,7 +471,7 @@ class ModalPort(PortBC):
         super().__init__(face)
 
         self.port_number: int= port_number
-        self.active: bool = active
+        self.active: bool = False
         self.power: float = power
         self.alignment_vectors: list[Axis] = []
 
@@ -666,7 +670,7 @@ class RectangularWaveguide(PortBC):
     def __init__(self, 
                  face: FaceSelection | GeoSurface,
                  port_number: int, 
-                 active: bool = False,
+                 mode: tuple[int, int] = (1,0),
                  cs: CoordinateSystem | None = None,
                  dims: tuple[float, float] | None = None,
                  power: float = 1):
@@ -681,7 +685,7 @@ class RectangularWaveguide(PortBC):
         Args:
             face (FaceSelection, GeoSurface): The port boundary face selection
             port_number (int): The port number
-            active (bool, optional): Ther the port is active. Defaults to False.
+            mode: (tuple[int, int], optional): The TE mode number. Defaults to (1,0).
             cs (CoordinateSystem, optional): The local coordinate system. Defaults to None.
             dims (tuple[float, float], optional): The port face. Defaults to None.
             power (float): The port power. Default to 1.
@@ -689,10 +693,10 @@ class RectangularWaveguide(PortBC):
         super().__init__(face)
 
         self.port_number: int= port_number
-        self.active: bool = active
+        self.active: bool = False
         self.power: float = power
         self.type: str = 'TE'
-        self.mode: tuple[int,int] = (1,0)
+        self.mode: tuple[int,int] = mode
 
         if dims is None:
             logger.info("Determining port face based on selection")
@@ -701,13 +705,12 @@ class RectangularWaveguide(PortBC):
             self.dims = (width, height)
             logger.debug(f'Port CS: {self.cs}')
             logger.debug(f'Detected port {self.port_number} size = {width*1000:.1f} mm x {height*1000:.1f} mm')
-        
+        else:
+            self.dims = dims
+            self.cs = cs
         if self.cs is None:
             logger.info('Constructing coordinate system from normal port')
             self.cs = Axis(self.selection.normal).construct_cs()
-        else:
-            self.cs: CoordinateSystem = cs # type: ignore
-
     def get_basis(self) -> np.ndarray:
         return self.cs._basis
         
@@ -755,11 +758,12 @@ class RectangularWaveguide(PortBC):
 
         width = self.dims[0]
         height = self.dims[1]
-
-        E = self.get_amplitude(k0)*np.cos(np.pi*self.mode[0]*(x_local)/width)*np.cos(np.pi*self.mode[1]*(y_local)/height)
-        Ex = 0*E
-        Ey = E
-        Ez = 0*E
+        m, n= self.mode
+        Ev = self.get_amplitude(k0)*np.cos(np.pi*m*(x_local)/width)*np.cos(np.pi*n*(y_local)/height)
+        Eh = self.get_amplitude(k0)*np.sin(np.pi*m*(x_local)/width)*np.sin(np.pi*n*(y_local)/height)
+        Ex = Eh
+        Ey = Ev
+        Ez = 0*Eh
         Exyz =  self._qmode(k0) * np.array([Ex, Ey, Ez])
         return Exyz
 
@@ -787,7 +791,6 @@ class LumpedPort(PortBC):
                  width: float | None = None,
                  height: float | None = None,
                  direction: Axis | None = None,
-                 active: bool = False,
                  power: float = 1,
                  Z0: float = 50):
         """Generates a lumped power boundary condition.
@@ -804,7 +807,6 @@ class LumpedPort(PortBC):
             width (float): The port width (meters).
             height (float): The port height (meters).
             direction (Axis): The port direction as an Axis object (em.Axis(..) or em.ZAX)
-            active (bool, optional): Whether the port is active. Defaults to False.
             power (float, optional): The port output power. Defaults to 1.
             Z0 (float, optional): The port impedance. Defaults to 50.
         """
@@ -819,7 +821,7 @@ class LumpedPort(PortBC):
         
         logger.debug(f'Lumped port: width={1000*width:.1f}mm, height={1000*height:.1f}mm, direction={direction}') # type: ignore
         self.port_number: int= port_number
-        self.active: bool = active
+        self.active: bool = False
 
         self.power: float = power
         self.Z0: float = Z0
@@ -829,9 +831,9 @@ class LumpedPort(PortBC):
         self.Vdirection: Axis = direction # type: ignore
         self.type = 'TEM'
         
-        logger.info('Constructing coordinate system from normal port')
-        self.cs = Axis(self.selection.normal).construct_cs()  # type: ignore
-
+        # logger.info('Constructing coordinate system from normal port')
+        # self.cs = Axis(self.selection.normal).construct_cs()  # type: ignore
+        self.cs = GCS
         self.vintline: Line | None = None
         self.v_integration = True
 
@@ -885,14 +887,7 @@ class LumpedPort(PortBC):
                      k0: float,
                      which: Literal['E','H'] = 'E') -> np.ndarray:
         ''' Compute the port mode E-field in local coordinates (XY) + Z out of plane.'''
-
-        px, py, pz = self.cs.in_local_basis(*self.Vdirection.np)
-        
-        Ex = px*np.ones_like(x_local)
-        Ey = py*np.ones_like(x_local)
-        Ez = pz*np.ones_like(x_local)
-        Exyz = np.array([Ex, Ey, Ez])
-        return Exyz
+        raise RuntimeError('This function should never be called in this context.')
 
     def port_mode_3d_global(self, 
                             x_global: np.ndarray,
@@ -915,10 +910,9 @@ class LumpedPort(PortBC):
         Returns:
             np.ndarray: The E-field in (3,N) indexing.
         """
-        xl, yl, _ = self.cs.in_local_cs(x_global, y_global, z_global)
-        Ex, Ey, Ez = self.port_mode_3d(xl, yl, k0)
-        Exg, Eyg, Ezg = self.cs.in_global_basis(Ex, Ey, Ez)
-        return np.array([Exg, Eyg, Ezg])
+        ON = np.ones_like(x_global)
+        Ex, Ey, Ez = self.Vdirection.np
+        return np.array([Ex*ON, Ey*ON, Ez*ON])
 
 
 class LumpedElement(RobinBC):

emerge/_emerge/physics/microwave/microwave_data.py

@@ -20,7 +20,7 @@ from ...simulation_data import BaseDataset, DataContainer
 from ...elements.femdata import FEMBasis
 from dataclasses import dataclass
 import numpy as np
-from typing import Literal
+from typing import Literal, Callable
 from loguru import logger
 from .adaptive_freq import SparamModel
 from ...cs import Axis, _parse_axis
@@ -1018,7 +1018,8 @@ class MWField:
         k0 = self.k0
         return vertices, triangles, E, H, origin, k0
     
-    def optycal_antenna(self, faces: FaceSelection | GeoSurface | None = None,
+    def optycal_antenna(self, 
+                        faces: FaceSelection | GeoSurface | None = None,
                         origin: tuple[float, float, float] | None = None,
                         syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> dict:
         """Export this models exterior to an Optical acceptable dataset
@@ -1036,6 +1037,32 @@ class MWField:
     
         return dict(freq=freq, ff_function=function)
 
+    # def surface_integral(self, faces: FaceSelection | GeoSurface, fieldfunction: Callable) -> float | complex:
+    #     """Computes a surface integral on the selected faces. 
+    
+    #     The fieldfunction argument must be a callable of a single argument x, which will
+    #     be of type EHField which is restuned by the field.interpolate(x,y,z) function. It has
+    #     fields like Ez, Ey, Sx etc that can be called. 
+
+    #     Args:
+    #         faces (FaceSelection | GeoSurface): _description_
+    #         fieldfunction (Callable): _description_
+
+    #     Returns:
+    #         float | complex: _description_
+    #     """
+    #     from ...mth.integrals import surface_integral
+        
+    #     def ff(x, y, z):
+    #         fieldobj = self.interpolate(x,y,z)
+    #         return fieldfunction(fieldobj)
+        
+    #     nodes = self.mesh.get_nodes(faces.tags)
+    #     triangles = self.mesh.get_triangles(faces.tags)
+        
+    #     return surface_integral(nodes, triangles, ff)
+        
+        
 class MWScalar:
     """The MWDataSet class stores solution data of FEM Time Harmonic simulations.
     """