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

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -269,7 +269,7 @@ class Microwave3D:
             Callable: The discretizer function
         """
         def disc(material: Material):
-            return 299792458/(max(self.frequencies) * np.real(material.neff))
+            return 299792458/(max(self.frequencies) * np.real(material.neff(max(self.frequencies))))
         return disc
     
     def _initialize_field(self):
@@ -467,10 +467,25 @@ class Microwave3D:
             raise SimulationError('Cannot proceed, the current basis class is undefined.')
 
         logger.debug('Retreiving material properties.')
-        ertet = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
-        urtet = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
-        condtet = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
+        
+        if freq is None:
+            freq = self.frequencies[0]
+        
+        materials = self.mesh.retreive(self.mesher.volumes)
 
+        ertet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
+        tandtet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
+        urtet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
+        condtet = np.zeros((3,3,self.mesh.n_tets), dtype=np.complex128)
+        
+        for mat in materials:
+            ertet = mat.er(freq, ertet)
+            tandtet = mat.tand(freq, tandtet)
+            urtet = mat.ur(freq, urtet)
+            condtet = mat.cond(freq, condtet)
+        
+        ertet = ertet * (1-1j*tandtet)
+        
         er = np.zeros((3,3,self.mesh.n_tris,), dtype=np.complex128)
         ur = np.zeros((3,3,self.mesh.n_tris,), dtype=np.complex128)
         cond = np.zeros((self.mesh.n_tris,), dtype=np.complex128)
@@ -479,7 +494,7 @@ class Microwave3D:
             itet = self.mesh.tri_to_tet[0,itri]
             er[:,:,itri] = ertet[:,:,itet]
             ur[:,:,itri] = urtet[:,:,itet]
-            cond[itri] = condtet[itet]
+            cond[itri] = condtet[0,0,itet]
 
         itri_port = self.mesh.get_triangles(port.tags)
 
@@ -488,11 +503,7 @@ class Microwave3D:
         ermax = np.max(er[:,:,itri_port].flatten())
         urmax = np.max(ur[:,:,itri_port].flatten())
 
-        if freq is None:
-            freq = self.frequencies[0]
-        
         k0 = 2*np.pi*freq/299792458
-        kmax = k0*np.sqrt(ermax.real*urmax.real)
         
         Amatrix, Bmatrix, solve_ids, nlf = self.assembler.assemble_bma_matrices(self.basis, er, ur, cond, k0, port, self.bc)
         
@@ -511,8 +522,7 @@ class Microwave3D:
             else:
                 
                 target_kz = ermean*urmean*0.7*k0
-
-    
+                
         logger.debug(f'Solving for {solve_ids.shape[0]} degrees of freedom.')
 
         eigen_values, eigen_modes, report = self.solveroutine.eig_boundary(Amatrix, Bmatrix, solve_ids, nmodes, direct, target_kz, sign=-1)
@@ -550,12 +560,10 @@ class Microwave3D:
             Ez = np.max(np.abs(Efz))
             Exy = np.max(np.abs(Efxy))
             
-            # Exy = np.max(np.max(Emode))
-            # Ez = 0
-            if Ez/Exy < 1e-3 and not TEM:
+            if Ez/Exy < 1e-1 and not TEM:
                 logger.debug('Low Ez/Et ratio detected, assuming TE mode')
                 mode.modetype = 'TE'
-            elif Ez/Exy > 1e-3 and not TEM:
+            elif Ez/Exy > 1e-1 and not TEM:
                 logger.debug('High Ez/Et ratio detected, assuming TM mode')
                 mode.modetype = 'TM'
             elif TEM:
@@ -621,9 +629,7 @@ class Microwave3D:
         if self.basis is None:
             raise SimulationError('Cannot proceed, the simulation basis class is undefined.')
 
-        er = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
-        ur = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
-        cond = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
+        materials = self.mesh.retreive(self.mesher.volumes)
 
         ### Does this move
         logger.debug('Initializing frequency domain sweep.')
@@ -674,7 +680,8 @@ class Microwave3D:
             freq_groups = [self.frequencies[i:i+n] for i in range(0, len(self.frequencies), n)]
 
         results: list[SimJob] = []
-
+        matset: list[tuple[np.ndarray, np.ndarray, np.ndarray]] = []
+        
         ## Single threaded
         job_id = 1
 
@@ -691,7 +698,7 @@ class Microwave3D:
                     logger.debug(f'Simulation frequency = {freq/1e9:.3f} GHz') 
                     if automatic_modal_analysis:
                         self._compute_modes(freq)
-                    job = self.assembler.assemble_freq_matrix(self.basis, er, ur, cond, 
+                    job, mats = self.assembler.assemble_freq_matrix(self.basis, materials, 
                                                             self.bc.boundary_conditions, 
                                                             freq, 
                                                             cache_matrices=self.cache_matrices)
@@ -700,6 +707,7 @@ class Microwave3D:
                     job.id = job_id
                     job_id += 1
                     jobs.append(job)
+                    matset.append(mats)
                 
                 logger.info(f'Starting single threaded solve of {len(jobs)} jobs.')
                 group_results = [run_job_single(job) for job in jobs]
@@ -716,7 +724,7 @@ class Microwave3D:
                         logger.debug(f'Simulation frequency = {freq/1e9:.3f} GHz') 
                         if automatic_modal_analysis:
                             self._compute_modes(freq)
-                        job = self.assembler.assemble_freq_matrix(self.basis, er, ur, cond, 
+                        job, mats = self.assembler.assemble_freq_matrix(self.basis, materials, 
                                                                 self.bc.boundary_conditions, 
                                                                 freq, 
                                                                 cache_matrices=self.cache_matrices)
@@ -725,6 +733,7 @@ class Microwave3D:
                         job.id = job_id
                         job_id += 1
                         jobs.append(job)
+                        matset.append(mats)
                     
                     logger.info(f'Starting distributed solve of {len(jobs)} jobs with {njobs} threads.')
                     group_results = list(executor.map(run_job, jobs))
@@ -749,8 +758,8 @@ class Microwave3D:
                         if automatic_modal_analysis:
                             self._compute_modes(freq)
                         
-                        job = self.assembler.assemble_freq_matrix(
-                            self.basis, er, ur, cond,
+                        job, mats = self.assembler.assemble_freq_matrix(
+                            self.basis, materials,
                             self.bc.boundary_conditions,
                             freq,
                             cache_matrices=self.cache_matrices
@@ -761,6 +770,7 @@ class Microwave3D:
                         job.id = job_id
                         job_id += 1
                         jobs.append(job)
+                        matset.append(mats)
 
                     logger.info(
                         f'Starting distributed solve of {len(jobs)} jobs '
@@ -783,7 +793,7 @@ class Microwave3D:
 
         self.solveroutine.reset()
         ### Compute S-parameters and return
-        self._post_process(results, er, ur, cond)
+        self._post_process(results, matset)
         return self.data
     
     def eigenmode(self, search_frequency: float,
@@ -817,19 +827,21 @@ class Microwave3D:
         if self.basis is None:
             raise SimulationError('Cannot proceed. The simulation basis class is undefined.')
 
-        er = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
-        ur = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
-        cond = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
+        materials = self.mesh.retreive(self.mesher.volumes)
+        
+        # er = self.mesh.retreive(lambda mat,x,y,z: mat.fer3d_mat(x,y,z), self.mesher.volumes)
+        # ur = self.mesh.retreive(lambda mat,x,y,z: mat.fur3d_mat(x,y,z), self.mesher.volumes)
+        # cond = self.mesh.retreive(lambda mat,x,y,z: mat.cond, self.mesher.volumes)[0,0,:]
 
         ### Does this move
         logger.debug('Initializing frequency domain sweep.')
             
         logger.info(f'Pre-assembling matrices of {len(self.frequencies)} frequency points.')
         
-        job = self.assembler.assemble_eig_matrix(self.basis, er, ur, cond, 
+        job, matset = self.assembler.assemble_eig_matrix(self.basis, materials, 
                                                             self.bc.boundary_conditions, search_frequency)
         
-
+        er, ur, cond = matset
         logger.info('Solving complete')
 
         A, C, solve_ids = job.yield_AC()
@@ -846,7 +858,7 @@ class Microwave3D:
 
         for i in range(nmodes_found):
             
-            Emode = np.zeros((self.basis.n_field,), dtype=np.complex128)
+
             eig_k0 = np.sqrt(eigen_values[i])
             if eig_k0 < k0_limit:
                 logger.debug(f'Ignoring mode due to low k0: {eig_k0} < {k0_limit}')
@@ -856,11 +868,11 @@ class Microwave3D:
             logger.debug(f'Found k0={eig_k0:.2f}, f0={eig_freq/1e9:.2f} GHz')
             Emode = eigen_modes[:,i]
 
-            scalardata = self.data.scalar.new(freq=eig_freq, **self._params)
+            scalardata = self.data.scalar.new(**self._params)
             scalardata.k0 = eig_k0
             scalardata.freq = eig_freq
 
-            fielddata = self.data.field.new(freq=eig_freq, **self._params)
+            fielddata = self.data.field.new(**self._params)
             fielddata.freq = eig_freq
             fielddata._der = np.squeeze(er[0,0,:])
             fielddata._dur = np.squeeze(ur[0,0,:])
@@ -870,7 +882,7 @@ class Microwave3D:
         
         return self.data
 
-    def _post_process(self, results: list[SimJob], er: np.ndarray, ur: np.ndarray, cond: np.ndarray):
+    def _post_process(self, results: list[SimJob], materials: list[tuple[np.ndarray, np.ndarray, np.ndarray]]):
         """Compute the S-parameters after Frequency sweep
 
         Args:
@@ -888,18 +900,19 @@ class Microwave3D:
 
         logger.info('Computing S-parameters')
         
-        ertri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
-        urtri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
-        condtri = np.zeros((self.mesh.n_tris,), dtype=np.complex128)
-
-        for itri in range(self.mesh.n_tris):
-            itet = self.mesh.tri_to_tet[0,itri]
-            ertri[:,:,itri] = er[:,:,itet]
-            urtri[:,:,itri] = ur[:,:,itet]
-            condtri[itri] = cond[itet]
-
-        for freq, job in zip(self.frequencies, results):
 
+        for freq, job, mats in zip(self.frequencies, results, materials):
+            er, ur, cond = mats
+            ertri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
+            urtri = np.zeros((3,3,self.mesh.n_tris), dtype=np.complex128)
+            condtri = np.zeros((self.mesh.n_tris,), dtype=np.complex128)
+
+            for itri in range(self.mesh.n_tris):
+                itet = self.mesh.tri_to_tet[0,itri]
+                ertri[:,:,itri] = er[:,:,itet]
+                urtri[:,:,itri] = ur[:,:,itet]
+                condtri[itri] = cond[0,0,itet]
+                
             k0 = 2*np.pi*freq/299792458
 
             scalardata = self.data.scalar.new(freq=freq, **self._params)

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -73,7 +73,7 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         """
         bcs = self.oftype(PEC)
         for bc in self.oftype(SurfaceImpedance):
-            if bc.material.cond > 1e3:
+            if bc.sigma > 1e3:
                 bcs.append(bc)
 
         return bcs
@@ -354,7 +354,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 +439,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 +456,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 +465,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 +664,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 +679,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 +687,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 +699,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 +752,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 +785,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 +801,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 +815,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
@@ -1034,12 +1030,13 @@ class SurfaceImpedance(RobinBC):
         self._material: Material | None = material
         self._mur: float | complex = 1.0
         self._epsr: float | complex = 1.0
-
         self.sigma: float = 0.0
+        
         if material is not None:
             self.sigma = material.cond
             self._mur = material.ur
             self._epsr = material.er
+        
         if surface_conductance is not None:
             self.sigma = surface_conductance
         
@@ -1066,10 +1063,15 @@ class SurfaceImpedance(RobinBC):
         Returns:
             complex: The γ-constant
         """
+        
         w0 = k0*C0
-        sigma = self.sigma
+        f0 = w0/(2*np.pi)
+        sigma = self.sigma.scalar(f0)
+        mur = self._material.ur.scalar(f0)
+        er = self._material.er.scalar(f0)
+        
         rho = 1/sigma
-        d_skin = (2*rho/(w0*MU0*self._mur) * ((1+(w0*EPS0*self._epsr*rho)**2)**0.5 + rho*w0*EPS0*self._epsr))**0.5
+        d_skin = (2*rho/(w0*MU0*mur) * ((1+(w0*EPS0*er*rho)**2)**0.5 + rho*w0*EPS0*er))**0.5
         R = rho/d_skin
         if self._sr_model=='Hammerstad-Jensen' and self._sr > 0.0:
             R = R * (1 + 2/np.pi * np.arctan(1.4*(self._sr/d_skin)**2))

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
@@ -282,9 +282,9 @@ class FarFieldData:
     
     @property
     def Etheta(self) -> np.ndarray:
-        thx = -np.cos(self.theta)*np.cos(self.phi)
-        thy = -np.cos(self.theta)*np.sin(self.phi)
-        thz = np.sin(self.theta)
+        thx = np.cos(self.theta)*np.cos(self.phi)
+        thy = np.cos(self.theta)*np.sin(self.phi)
+        thz = -np.sin(self.theta)
         return thx*self.E[0,:] + thy*self.E[1,:] + thz*self.E[2,:]
     
     @property
@@ -296,11 +296,11 @@ class FarFieldData:
     
     @property
     def Erhcp(self) -> np.ndarray:
-        return (self.Etheta - 1j*self.Ephi)/np.sqrt(2)
+        return (self.Etheta + 1j*self.Ephi)/np.sqrt(2)
     
     @property
     def Elhcp(self) -> np.ndarray:
-        return (self.Etheta + 1j*self.Ephi)/np.sqrt(2)
+        return (self.Etheta - 1j*self.Ephi)/np.sqrt(2)
     
     @property
     def AR(self) -> np.ndarray:
@@ -702,6 +702,11 @@ class MWField:
     
     def interpolate(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray) -> EHField:
         ''' Interpolate the dataset in the provided xs, ys, zs values'''
+        if isinstance(xs, (float, int, complex)):
+            xs = np.array([xs,])
+            ys = np.array([ys,])
+            zs = np.array([zs,])
+            
         shp = xs.shape
         xf = xs.flatten()
         yf = ys.flatten()
@@ -748,6 +753,7 @@ class MWField:
         xs = np.linspace(xb[0], xb[1], int((xb[1]-xb[0])/ds))
         ys = np.linspace(yb[0], yb[1], int((yb[1]-yb[0])/ds))
         zs = np.linspace(zb[0], zb[1], int((zb[1]-zb[0])/ds))
+        
         if x is not None:
             Y,Z = np.meshgrid(ys, zs)
             X = x*np.ones_like(Y)
@@ -759,6 +765,56 @@ class MWField:
             Z = z*np.ones_like(Y)
         return self.interpolate(X,Y,Z)
     
+    def cutplane_normal(self,
+             point=(0,0,0),
+             normal=(0,0,1),
+             npoints: int = 300) -> EHField:
+        """
+        Take a 2D slice of the field along an arbitrary plane.
+        Args:
+            point: (x0,y0,z0), a point on the plane
+            normal: (nx,ny,nz), plane normal vector
+            npoints: number of grid points per axis
+        """
+
+        n = np.array(normal, dtype=float)
+        n /= np.linalg.norm(n)
+        point = np.array(point) 
+
+        tmp = np.array([1,0,0]) if abs(n[0]) < 0.9 else np.array([0,1,0])
+        u = np.cross(n, tmp)
+        u /= np.linalg.norm(u)
+        v = np.cross(n, u)
+        
+        xb, yb, zb = self.basis.bounds
+        nx, ny, nz = 5, 5, 5
+        Xg = np.linspace(xb[0], xb[1], nx)
+        Yg = np.linspace(yb[0], yb[1], ny)
+        Zg = np.linspace(zb[0], zb[1], nz)
+        Xg, Yg, Zg = np.meshgrid(Xg, Yg, Zg, indexing='ij')
+        geometry = np.vstack([Xg.ravel(), Yg.ravel(), Zg.ravel()]).T  # Nx3
+        
+        rel_pts = geometry - point
+        S = rel_pts @ u
+        T = rel_pts @ v 
+        
+        margin = 0.01
+        s_min, s_max = S.min(), S.max()
+        t_min, t_max = T.min(), T.max()
+        s_bounds = (s_min - margin*(s_max-s_min), s_max + margin*(s_max-s_min))
+        t_bounds = (t_min - margin*(t_max-t_min), t_max + margin*(t_max-t_min))
+
+        S_grid = np.linspace(s_bounds[0], s_bounds[1], npoints)
+        T_grid = np.linspace(t_bounds[0], t_bounds[1], npoints)
+        S_mesh, T_mesh = np.meshgrid(S_grid, T_grid)
+
+        X = point[0] + S_mesh*u[0] + T_mesh*v[0]
+        Y = point[1] + S_mesh*u[1] + T_mesh*v[1]
+        Z = point[2] + S_mesh*u[2] + T_mesh*v[2]
+
+        return self.interpolate(X, Y, Z)
+    
+    
     def grid(self, ds: float) -> EHField:
         """Interpolate a uniform grid sampled at ds
 
@@ -962,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
@@ -980,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.
     """