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

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)

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
@@ -787,7 +787,6 @@ class LumpedPort(PortBC):
                  width: float | None = None,
                  height: float | None = None,
                  direction: Axis | None = None,
-                 Idirection: Axis | None = None,
                  active: bool = False,
                  power: float = 1,
                  Z0: float = 50):
@@ -814,7 +813,7 @@ class LumpedPort(PortBC):
         if width is None:
             if not isinstance(face, GeoObject):
                 raise ValueError(f'The width, height and direction must be defined. Information cannot be extracted from {face}')
-            width, height, direction, Idirection = face._data('width','height','vdir', 'idir')
+            width, height, direction = face._data('width','height','vdir')
             if width is None or height is None or direction is None:
                 raise ValueError(f'The width, height and direction could not be extracted from {face}')
         
@@ -828,7 +827,6 @@ class LumpedPort(PortBC):
         self.width: float = width
         self.height: float = height # type: ignore
         self.Vdirection: Axis = direction # type: ignore
-        self.Idirection: Axis = Idirection # type: ignore
         self.type = 'TEM'
         
         logger.info('Constructing coordinate system from normal port')
@@ -836,7 +834,6 @@ class LumpedPort(PortBC):
 
         self.vintline: Line | None = None
         self.v_integration = True
-        self.iintline: Line | None = None
 
     @property
     def surfZ(self) -> float:
@@ -923,6 +920,7 @@ class LumpedPort(PortBC):
         Exg, Eyg, Ezg = self.cs.in_global_basis(Ex, Ey, Ez)
         return np.array([Exg, Eyg, Ezg])
 
+
 class LumpedElement(RobinBC):
     
     _include_stiff: bool = True
@@ -1036,12 +1034,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
         
@@ -1068,10 +1067,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

@@ -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()
@@ -731,10 +736,24 @@ class MWField:
                      x: float | None = None,
                      y: float | None = None,
                      z: float | None = None) -> EHField:
+        """Create a cartesian cut plane (XY, YZ or XZ) and compute the E and H-fields there
+
+        Only one coordiante and thus cutplane may be defined. If multiple are defined only the last (x->y->z) is used.
+        
+        Args:
+            ds (float): The discretization step size
+            x (float | None, optional): The X-coordinate in case of a YZ-plane. Defaults to None.
+            y (float | None, optional): The Y-coordinate in case of an XZ-plane. Defaults to None.
+            z (float | None, optional): The Z-coordinate in case of an XY-plane. Defaults to None.
+
+        Returns:
+            EHField: The resultant EHField object
+        """
         xb, yb, zb = self.basis.bounds
         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)
@@ -746,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