emerge 1.0.5__py3-none-any.whl → 1.0.7__py3-none-any.whl

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

@@ -244,24 +244,24 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
 
             L2 = edge_lengths[ej]
 
-            BB1 = matmul(Mm,GC)
-            BC1 = matmul(Mm,GD)
-            BD1 = dot_c(GA,BB1)
-            BE1 = dot_c(GA,BC1)
-            BF1 = dot_c(GB,BB1)
-            BG1 = dot_c(GB,BC1)
-
-            Q2 = L1*L2
-            Q = Q2*9*dot_c(cross_c(GA,GB),matmul(Ms,cross_c(GC,GD)))
-            Dmat[ei+0,ej+0] = Q*VAC
-            Dmat[ei+0,ej+10] = Q*VAD
-            Dmat[ei+10,ej+0] = Q*VBC
-            Dmat[ei+10,ej+10] = Q*VBD
+            erGF = matmul(Mm,GC)
+            erGC = matmul(Mm,GD)
+            erGD = dot_c(GA,erGF)
+            GE_MUL_erGF = dot_c(GA,erGC)
+            GE_MUL_erGC = dot_c(GB,erGF)
+            GA_MUL_erGF = dot_c(GB,erGC)
+
+            L12 = L1*L2
+            Factor = L12*9*dot_c(cross_c(GA,GB),matmul(Ms,cross_c(GC,GD)))
+            Dmat[ei+0,ej+0] = Factor*VAC
+            Dmat[ei+0,ej+10] = Factor*VAD
+            Dmat[ei+10,ej+0] = Factor*VBC
+            Dmat[ei+10,ej+10] = Factor*VBD
             
-            Fmat[ei+0,ej+0] = Q2*(VABCD*BD1-VABCC*BE1-VAACD*BF1+VAACC*BG1)
-            Fmat[ei+0,ej+10] = Q2*(VABDD*BD1-VABCD*BE1-VAADD*BF1+VAACD*BG1)
-            Fmat[ei+10,ej+0] = Q2*(VBBCD*BD1-VBBCC*BE1-VABCD*BF1+VABCC*BG1)
-            Fmat[ei+10,ej+10] = Q2*(VBBDD*BD1-VBBCD*BE1-VABDD*BF1+VABCD*BG1)       
+            Fmat[ei+0,ej+0] = L12*(VABCD*erGD-VABCC*GE_MUL_erGF-VAACD*GE_MUL_erGC+VAACC*GA_MUL_erGF)
+            Fmat[ei+0,ej+10] = L12*(VABDD*erGD-VABCD*GE_MUL_erGF-VAADD*GE_MUL_erGC+VAACD*GA_MUL_erGF)
+            Fmat[ei+10,ej+0] = L12*(VBBCD*erGD-VBBCC*GE_MUL_erGF-VABCD*GE_MUL_erGC+VABCC*GA_MUL_erGF)
+            Fmat[ei+10,ej+10] = L12*(VBBDD*erGD-VBBCD*GE_MUL_erGF-VABDD*GE_MUL_erGC+VABCD*GA_MUL_erGF)       
 
         for ej in range(4):
             ej1, ej2, fj = local_tri_map[:, ej]
@@ -292,29 +292,29 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             Lab2 = Ds[ej1, ej2]
             Lac2 = Ds[ej1, fj]
             
-            AB1 = cross_c(GA,GB)
-            AI1 = dot_c(AB1,matmul(Ms,cross_c(GC,GF)))
-            AJ1 = dot_c(AB1,matmul(Ms,cross_c(GD,GF)))
-            AK1 = dot_c(AB1,matmul(Ms,cross_c(GC,GD)))
-            BB1 = matmul(Mm,GF)
-            BC1 = matmul(Mm,GC)
-            BD1 = matmul(Mm,GD)
-            BE1 = dot_c(GA,BB1)
-            BF1 = dot_c(GA,BC1)
-            BG1 = dot_c(GB,BB1)
-            BH1 = dot_c(GB,BC1)
-            BI1 = dot_c(GA,BD1)
-            BJ1 = dot_c(GB,BD1)
+            CROSS_AE = cross_c(GA,GB)
+            CROSS_DF = dot_c(CROSS_AE,matmul(Ms,cross_c(GC,GF)))
+            CROSS_CD = dot_c(CROSS_AE,matmul(Ms,cross_c(GD,GF)))
+            AE_MUL_CF = dot_c(CROSS_AE,matmul(Ms,cross_c(GC,GD)))
+            erGF = matmul(Mm,GF)
+            erGC = matmul(Mm,GC)
+            erGD = matmul(Mm,GD)
+            GE_MUL_erGF = dot_c(GA,erGF)
+            GE_MUL_erGC = dot_c(GA,erGC)
+            GA_MUL_erGF = dot_c(GB,erGF)
+            GA_MUL_erGC = dot_c(GB,erGC)
+            GE_MUL_erGD = dot_c(GA,erGD)
+            GA_MUL_erGD = dot_c(GB,erGD)
             
-            Dmat[ei+0,ej+6] = L1*Lac2*(-6*VAD*AI1-3*VAC*AJ1-3*VAF*AK1)
-            Dmat[ei+0,ej+16] = L1*Lab2*(6*VAF*AK1+3*VAD*AI1-3*VAC*AJ1)
-            Dmat[ei+10,ej+6] = L1*Lac2*(-6*VBD*AI1-3*VBC*AJ1-3*VBF*AK1)
-            Dmat[ei+10,ej+16] = L1*Lab2*(6*VBF*AK1+3*VBD*AI1-3*VBC*AJ1)
-
-            Fmat[ei+0,ej+6] = L1*Lac2*(VABCD*BE1-VABDF*BF1-VAACD*BG1+VAADF*BH1)
-            Fmat[ei+0,ej+16] = L1*Lab2*(VABDF*BF1-VABCF*BI1-VAADF*BH1+VAACF*BJ1)
-            Fmat[ei+10,ej+6] = L1*Lac2*(VBBCD*BE1-VBBDF*BF1-VABCD*BG1+VABDF*BH1)
-            Fmat[ei+10,ej+16] = L1*Lab2*(VBBDF*BF1-VBBCF*BI1-VABDF*BH1+VABCF*BJ1)
+            Dmat[ei+0,ej+6] = L1*Lac2*(-6*VAD*CROSS_DF-3*VAC*CROSS_CD-3*VAF*AE_MUL_CF)
+            Dmat[ei+0,ej+16] = L1*Lab2*(6*VAF*AE_MUL_CF+3*VAD*CROSS_DF-3*VAC*CROSS_CD)
+            Dmat[ei+10,ej+6] = L1*Lac2*(-6*VBD*CROSS_DF-3*VBC*CROSS_CD-3*VBF*AE_MUL_CF)
+            Dmat[ei+10,ej+16] = L1*Lab2*(6*VBF*AE_MUL_CF+3*VBD*CROSS_DF-3*VBC*CROSS_CD)
+
+            Fmat[ei+0,ej+6] = L1*Lac2*(VABCD*GE_MUL_erGF-VABDF*GE_MUL_erGC-VAACD*GA_MUL_erGF+VAADF*GA_MUL_erGC)
+            Fmat[ei+0,ej+16] = L1*Lab2*(VABDF*GE_MUL_erGC-VABCF*GE_MUL_erGD-VAADF*GA_MUL_erGC+VAACF*GA_MUL_erGD)
+            Fmat[ei+10,ej+6] = L1*Lac2*(VBBCD*GE_MUL_erGF-VBBDF*GE_MUL_erGC-VABCD*GA_MUL_erGF+VABDF*GA_MUL_erGC)
+            Fmat[ei+10,ej+16] = L1*Lab2*(VBBDF*GE_MUL_erGC-VBBCF*GE_MUL_erGD-VABDF*GA_MUL_erGC+VABCF*GA_MUL_erGD)
     
     ## Mirror the transpose part of the previous iteration as its symmetrical
 
@@ -335,6 +335,7 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
         GE = GLs[fi]
         Lac1 = Ds[ei1, fi]
         Lab1 = Ds[ei1, ei2]
+        
         for ej in range(4):
             ej1, ej2, fj = local_tri_map[:, ej]
             
@@ -366,44 +367,44 @@ def ned2_tet_stiff_mass(tet_vertices, edge_lengths, local_edge_map, local_tri_ma
             Lac2 = Ds[ej1, fj]
             Lab2 = Ds[ej1, ej2]
 
-            AB1 = cross_c(GA,GE)
-            AF1 = cross_c(GB,GE)
-            AG1 = cross_c(GA,GB)
-            AH1 = matmul(Ms,cross_c(GC,GF))
-            AI1 = matmul(Ms,cross_c(GD,GF))
-            AJ1 = matmul(Ms,cross_c(GC,GD))
-            AK1 = dot_c(AB1,AH1)
-            AL1 = dot_c(AB1,AI1)
-            AM1 = dot_c(AB1,AJ1)
-            AN1 = dot_c(AF1,AH1)
-            AO1 = dot_c(AF1,AI1)
-            AP1 = dot_c(AF1,AJ1)
-            AQ1 = dot_c(AG1,AH1)
-            AR1 = dot_c(AG1,AI1)
-            AS1 = dot_c(AG1,AJ1)
-            BB1 = matmul(Mm,GF)
-            BC1 = matmul(Mm,GC)
-            BD1 = matmul(Mm,GD)
-            BE1 = dot_c(GE,BB1)
-            BF1 = dot_c(GE,BC1)
-            BG1 = dot_c(GA,BB1)
-            BH1 = dot_c(GA,BC1)
-            BI1 = dot_c(GE,BD1)
-            BJ1 = dot_c(GA,BD1)
-            BK1 = dot_c(GB,BB1)
-            BL1 = dot_c(GB,BC1)
-            BM1 = dot_c(GB,BD1)
-
-            Q1 = 2*VAD*AN1+VAC*AO1+VAF*AP1
-            Q2 = -2*VAF*AP1-VAD*AN1+VAC*AO1
-            Dmat[ei+6,ej+6] = Lac1*Lac2*(4*VBD*AK1+2*VBC*AL1+2*VBF*AM1+Q1+2*VDE*AQ1+VCE*AR1+VEF*AS1)
-            Dmat[ei+6,ej+16] = Lac1*Lab2*(-4*VBF*AM1-2*VBD*AK1+2*VBC*AL1+Q2-2*VEF*AS1-VDE*AQ1+VCE*AR1)
-            Dmat[ei+16,ej+6] = Lab1*Lac2*(-4*VDE*AQ1-2*VCE*AR1-2*VEF*AS1-2*VBD*AK1-VBC*AL1-VBF*AM1+Q1)
-            Dmat[ei+16,ej+16] = Lab1*Lab2*(4*VEF*AS1+2*VDE*AQ1-2*VCE*AR1+2*VBF*AM1+VBD*AK1-VBC*AL1+Q2)
-            Fmat[ei+6,ej+6] = Lac1*Lac2*(VABCD*BE1-VABDF*BF1-VBCDE*BG1+VBDEF*BH1)
-            Fmat[ei+6,ej+16] = Lac1*Lab2*(VABDF*BF1-VABCF*BI1-VBDEF*BH1+VBCEF*BJ1)
-            Fmat[ei+16,ej+6] = Lab1*Lac2*(VBCDE*BG1-VBDEF*BH1-VACDE*BK1+VADEF*BL1)
-            Fmat[ei+16,ej+16] = Lab1*Lab2*(VBDEF*BH1-VBCEF*BJ1-VADEF*BL1+VACEF*BM1)
+            CROSS_AE = cross_c(GA,GE)
+            CROSS_BE = cross_c(GB,GE)
+            CROSS_AB = cross_c(GA,GB)
+            CROSS_CF = matmul(Ms,cross_c(GC,GF))
+            CROSS_DF = matmul(Ms,cross_c(GD,GF))
+            CROSS_CD = matmul(Ms,cross_c(GC,GD))
+            AE_MUL_CF = dot_c(CROSS_AE,CROSS_CF)
+            AE_MUL_DF = dot_c(CROSS_AE,CROSS_DF)
+            AE_MUL_CD = dot_c(CROSS_AE,CROSS_CD)
+            BE_MUL_CF = dot_c(CROSS_BE,CROSS_CF)
+            BE_MUL_DF = dot_c(CROSS_BE,CROSS_DF)
+            BE_MUL_CD = dot_c(CROSS_BE,CROSS_CD)
+            AB_MUL_CF = dot_c(CROSS_AB,CROSS_CF)
+            AB_MUL_DF = dot_c(CROSS_AB,CROSS_DF)
+            AB_MUL_CD = dot_c(CROSS_AB,CROSS_CD)
+            erGF = matmul(Mm,GF)
+            erGC = matmul(Mm,GC)
+            erGD = matmul(Mm,GD)
+            GE_MUL_erGF = dot_c(GE,erGF)
+            GE_MUL_erGC = dot_c(GE,erGC)
+            GA_MUL_erGF = dot_c(GA,erGF)
+            GA_MUL_erGC = dot_c(GA,erGC)
+            GE_MUL_erGD = dot_c(GE,erGD)
+            GA_MUL_erGD = dot_c(GA,erGD)
+            GB_MUL_erGF = dot_c(GB,erGF)
+            GB_MUL_erGC = dot_c(GB,erGC)
+            GB_MUL_erGD = dot_c(GB,erGD)
+
+            Q1 = 2*VAD*BE_MUL_CF+VAC*BE_MUL_DF+VAF*BE_MUL_CD
+            L12 = -2*VAF*BE_MUL_CD-VAD*BE_MUL_CF+VAC*BE_MUL_DF
+            Dmat[ei+6,ej+6] = Lac1*Lac2*(4*VBD*AE_MUL_CF+2*VBC*AE_MUL_DF+2*VBF*AE_MUL_CD+Q1+2*VDE*AB_MUL_CF+VCE*AB_MUL_DF+VEF*AB_MUL_CD)
+            Dmat[ei+6,ej+16] = Lac1*Lab2*(-4*VBF*AE_MUL_CD-2*VBD*AE_MUL_CF+2*VBC*AE_MUL_DF+L12-2*VEF*AB_MUL_CD-VDE*AB_MUL_CF+VCE*AB_MUL_DF)
+            Dmat[ei+16,ej+6] = Lab1*Lac2*(-4*VDE*AB_MUL_CF-2*VCE*AB_MUL_DF-2*VEF*AB_MUL_CD-2*VBD*AE_MUL_CF-VBC*AE_MUL_DF-VBF*AE_MUL_CD+Q1)
+            Dmat[ei+16,ej+16] = Lab1*Lab2*(4*VEF*AB_MUL_CD+2*VDE*AB_MUL_CF-2*VCE*AB_MUL_DF+2*VBF*AE_MUL_CD+VBD*AE_MUL_CF-VBC*AE_MUL_DF+L12)
+            Fmat[ei+6,ej+6] = Lac1*Lac2*(VABCD*GE_MUL_erGF-VABDF*GE_MUL_erGC-VBCDE*GA_MUL_erGF+VBDEF*GA_MUL_erGC)
+            Fmat[ei+6,ej+16] = Lac1*Lab2*(VABDF*GE_MUL_erGC-VABCF*GE_MUL_erGD-VBDEF*GA_MUL_erGC+VBCEF*GA_MUL_erGD)
+            Fmat[ei+16,ej+6] = Lab1*Lac2*(VBCDE*GA_MUL_erGF-VBDEF*GA_MUL_erGC-VACDE*GB_MUL_erGF+VADEF*GB_MUL_erGC)
+            Fmat[ei+16,ej+16] = Lab1*Lab2*(VBDEF*GA_MUL_erGC-VBCEF*GA_MUL_erGD-VADEF*GB_MUL_erGC+VACEF*GB_MUL_erGD)
 
     Dmat = Dmat*KA
     Fmat = Fmat*KB

emerge/_emerge/physics/microwave/microwave_3d.py

@@ -19,7 +19,7 @@ from ...mesher import Mesher
 from ...material import Material
 from ...mesh3d import Mesh3D
 from ...coord import Line
-from ...geometry import GeoSurface
+from ...geometry import GeoSurface, _GEOMANAGER
 from ...elements.femdata import FEMBasis
 from ...elements.nedelec2 import Nedelec2
 from ...solver import DEFAULT_ROUTINE, SolveRoutine
@@ -61,6 +61,9 @@ def run_job_multi(job: SimJob) -> SimJob:
         job.submit_solution(solution, report)
     return job
 
+def _init_worker():
+    nr = int(mp.current_process().name.split('-')[1])
+    DEFAULT_ROUTINE._configure_routine(proc_nr=nr)
 
 def _dimstring(data: list[float] | np.ndarray) -> str:
     """A String formatter for dimensions in millimeters
@@ -137,11 +140,13 @@ class Microwave3D:
     def reset_data(self):
         self.data = MWData()
 
-    def reset(self):
-        self.bc.reset()
+    def reset(self, _reset_bc: bool = True):
+        if _reset_bc:
+            self.bc.reset()
+            self.bc = MWBoundaryConditionSet(None)
         self.basis: FEMBasis = None
-        self.bc = MWBoundaryConditionSet(None)
         self.solveroutine.reset()
+        self.assembler.cached_matrices = None
 
     def set_order(self, order: int) -> None:
         """Sets the order of the basis functions used. Currently only supports second order.
@@ -190,7 +195,6 @@ class Microwave3D:
                     logger.debug(f'Assinging PEC to {surf}')
                     self.bc.PEC(surf)
                 elif surf.material.cond.scalar(1e9) > self._settings.mw_2dbc_lim:
-                    logger.debug(f'Assigning SurfaceImpedance to {surf}')
                     self.bc.SurfaceImpedance(surf, surf.material)
                 
         
@@ -399,8 +403,10 @@ class Microwave3D:
             raise ValueError('The field basis is not yet defined.')
 
         logger.debug(' - Finding PEC TEM conductors')
-        pecs: list[PEC] = self.bc.get_conductors() # type: ignore
         mesh = self.mesh
+        
+        # Find all BC conductors
+        pecs: list[PEC] = self.bc.get_conductors() # type: ignore
 
         # Process all PEC Boundary Conditions
         pec_edges = []
@@ -416,19 +422,37 @@ class Microwave3D:
                 edge_ids = list(mesh.tri_to_edge[:,itri].flatten())
                 pec_edges.extend(edge_ids)
 
+        # All PEC edges
         pec_edges = list(set(pec_edges))
         
+        # Port mesh data
         tri_ids = mesh.get_triangles(port.tags)
         edge_ids = list(mesh.tri_to_edge[:,tri_ids].flatten())
         
-        pec_port = np.array([i for i in pec_edges if i in set(edge_ids)])
+        port_pec_edges = np.array([i for i in pec_edges if i in set(edge_ids)])
         
-        pec_islands = mesh.find_edge_groups(pec_port)
+        pec_islands = mesh.find_edge_groups(port_pec_edges)
 
+        
         logger.debug(f' - Found {len(pec_islands)} PEC islands.')
 
         if len(pec_islands) != 2:
-            raise ValueError(f' - Found {len(pec_islands)} PEC islands. Expected 2.')
+            pec_island_tags = {i: self.mesh._get_dimtags(edges=pec_edge_group) for i,pec_edge_group in enumerate(pec_islands)}
+            plus_term = None
+            min_term = None
+            
+            for i, dimtags in pec_island_tags.items():
+                if not set(dimtags).isdisjoint(port.plus_terminal):
+                    plus_term = i
+                
+                if not set(dimtags).isdisjoint(port.minus_terminal):
+                    min_term = i
+            
+            if plus_term is None or min_term is None:
+                raise ValueError(f' - Found {len(pec_islands)} PEC islands without a terminal definition. Please use .set_terminals() to define which conductors are which polarity.')    
+            logger.debug(f'Positive island = {pec_island_tags[plus_term]}')
+            logger.debug(f'Negative island = {pec_island_tags[min_term]}')
+            pec_islands = [pec_islands[plus_term], pec_islands[min_term]]
         
         groups = []
         for island in pec_islands:
@@ -601,6 +625,7 @@ class Microwave3D:
             elif TEM:
                 G1, G2 = self._find_tem_conductors(port, sigtri=cond)
                 cs, dls = self._compute_integration_line(G1,G2)
+                logger.debug(f'Integrating portmode from {cs[:,0]} to {cs[:,-1]}')
                 mode.modetype = 'TEM'
                 Ex, Ey, Ez = portfE(cs[0,:], cs[1,:], cs[2,:])
                 voltage = np.sum(Ex*dls[0,:] + Ey*dls[1,:] + Ez*dls[2,:])
@@ -619,7 +644,7 @@ class Microwave3D:
     
     def run_sweep(self, 
                 parallel: bool = False,
-                njobs: int = 2, 
+                n_workers: int = 2, 
                 harddisc_threshold: int | None = None,
                 harddisc_path: str = 'EMergeSparse',
                 frequency_groups: int = -1,
@@ -627,7 +652,7 @@ class Microwave3D:
                 automatic_modal_analysis: bool = True) -> MWData:
         """Executes a frequency domain study
 
-        The study is distributed over "njobs" workers.
+        The study is distributed over "n_workers" workers.
         As optional parameter you may set a harddisc_threshold as integer. This determines the maximum
         number of degrees of freedom before which the jobs will be cahced to the harddisk. The
         path that will be used to cache the sparse matrices can be specified.
@@ -637,7 +662,7 @@ class Microwave3D:
         frequency indices will be precomputed and then solved: [[1,2,3,4],[5,6,7,8],[9,10,11]]
 
         Args:
-            njobs (int, optional): The number of jobs. Defaults to 2.
+            n_workers (int, optional): The number of workers. Defaults to 2.
             harddisc_threshold (int, optional): The number of DOF limit. Defaults to None.
             harddisc_path (str, optional): The cached matrix path name. Defaults to 'EMergeSparse'.
             frequency_groups (int, optional): The number of frequency points in a solve group. Defaults to -1.
@@ -687,7 +712,8 @@ class Microwave3D:
         ## DEFINE SOLVE FUNCTIONS
         def get_routine():
             if not hasattr(thread_local, "routine"):
-                thread_local.routine = self.solveroutine.duplicate()._configure_routine('MT')
+                worker_nr = int(threading.current_thread().name.split('_')[1])+1
+                thread_local.routine = self.solveroutine.duplicate()._configure_routine('MT', thread_nr=worker_nr)
             return thread_local.routine
 
         def run_job(job: SimJob):
@@ -750,7 +776,7 @@ class Microwave3D:
                 results.extend(group_results)
         elif not multi_processing:
              # MULTI THREADED
-            with ThreadPoolExecutor(max_workers=njobs) as executor:
+            with ThreadPoolExecutor(max_workers=n_workers, thread_name_prefix='WKR') as executor:
                 # ITERATE OVER FREQUENCIES
                 for i_group, fgroup in enumerate(freq_groups):
                     logger.info(f'Precomputing group {i_group}.')
@@ -771,7 +797,7 @@ class Microwave3D:
                         jobs.append(job)
                         matset.append(mats)
                     
-                    logger.info(f'Starting distributed solve of {len(jobs)} jobs with {njobs} threads.')
+                    logger.info(f'Starting distributed solve of {len(jobs)} jobs with {n_workers} threads.')
                     group_results = list(executor.map(run_job, jobs))
                     results.extend(group_results)
                 executor.shutdown()
@@ -784,7 +810,7 @@ class Microwave3D:
                     "if __name__ == '__main__' guard in the top-level script."
                 )
             # Start parallel pool
-            with mp.Pool(processes=njobs) as pool:
+            with mp.Pool(processes=n_workers, initializer=_init_worker) as pool:
                 for i_group, fgroup in enumerate(freq_groups):
                     logger.debug(f'Precomputing group {i_group}.')
                     jobs = []
@@ -810,7 +836,7 @@ class Microwave3D:
 
                     logger.info(
                         f'Starting distributed solve of {len(jobs)} jobs '
-                        f'with {njobs} processes in parallel'
+                        f'with {n_workers} processes in parallel'
                     )
                     # Distribute taks
                     group_results = pool.map(run_job_multi, jobs)
@@ -832,6 +858,100 @@ class Microwave3D:
         self._post_process(results, matset)
         return self.data
     
+    def _run_adaptive_mesh(self,
+                iteration: int, 
+                frequency: float,
+                automatic_modal_analysis: bool = True) -> MWData:
+        """Executes a frequency domain study
+
+        The study is distributed over "n_workers" workers.
+        As optional parameter you may set a harddisc_threshold as integer. This determines the maximum
+        number of degrees of freedom before which the jobs will be cahced to the harddisk. The
+        path that will be used to cache the sparse matrices can be specified.
+        Additionally the term frequency_groups may be specified. This number will define in how
+        many groups the matrices will be pre-computed before they are send to workers. This can minimize
+        the total amound of RAM memory used. For example with 11 frequencies in gruops of 4, the following
+        frequency indices will be precomputed and then solved: [[1,2,3,4],[5,6,7,8],[9,10,11]]
+
+        Args:
+            iteration (int): The iteration number
+            frequency (float): The simulation frequency
+
+        Raises:
+            SimulationError: An error associated witha a problem during the simulation.
+
+        Returns:
+            MWSimData: The dataset.
+        """
+        
+        self._simstart = time.time()
+        if self.bc._initialized is False:
+            raise SimulationError('Cannot run a modal analysis because no boundary conditions have been assigned.')
+        
+        self._initialize_field()
+        self._initialize_bc_data()
+        self._check_physics()
+        
+        if self.basis is None:
+            raise SimulationError('Cannot proceed, the simulation basis class is undefined.')
+
+        materials = self.mesh._get_material_assignment(self.mesher.volumes)
+
+        ### Does this move
+        logger.debug('Initializing single frequency settings.')
+        
+        #### Port settings
+        all_ports = self.bc.oftype(PortBC)
+
+        ##### FOR PORT SWEEP SET ALL ACTIVE TO FALSE. THIS SHOULD BE FIXED LATER
+        ### COMPUTE WHICH TETS ARE CONNECTED TO PORT INDICES
+
+        for port in all_ports:
+            port.active=False
+    
+    
+        def run_job_single(job: SimJob):
+            for A, b, ids, reuse, aux in job.iter_Ab():
+                solution, report = self.solveroutine.solve(A, b, ids, reuse, id=job.id)
+                report.add(**aux)
+                job.submit_solution(solution, report)
+            return job
+        
+        
+        matset: list[tuple[np.ndarray, np.ndarray, np.ndarray]] = []     
+
+        self._compute_modes(frequency)
+
+        logger.debug(f'Simulation frequency = {frequency/1e9:.3f} GHz') 
+        
+        if automatic_modal_analysis:
+            self._compute_modes(frequency)
+            
+        job, mats = self.assembler.assemble_freq_matrix(self.basis, materials, 
+                                                self.bc.boundary_conditions, 
+                                                frequency, 
+                                                cache_matrices=self.cache_matrices)
+
+        job.id = 0
+
+        logger.info('Starting solve')
+        job = run_job_single(job)
+
+    
+        logger.info('Solving complete')
+
+        self.data.setreport(job.reports, freq=frequency, **self._params)
+
+        for variables, data in self.data.sim.iterate():
+            logger.trace(f'Sim variable: {variables}')
+            for item in data['report']:
+                item.logprint(logger.trace)
+
+        self.solveroutine.reset()
+        ### Compute S-parameters and return
+        self._post_process([job,], [mats,])
+        return self.data
+    
     def eigenmode(self, search_frequency: float,
                         nmodes: int = 6,
                         k0_limit: float = 1,
@@ -865,10 +985,6 @@ class Microwave3D:
 
         materials = self.mesh._get_material_assignment(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.')
             

emerge/_emerge/physics/microwave/microwave_bc.py

@@ -73,7 +73,6 @@ class MWBoundaryConditionSet(BoundaryConditionSet):
         for bc in self.oftype(SurfaceImpedance):
             if bc.sigma > 10.0:
                 bcs.append(bc)
-
         return bcs
         
     def get_type(self, bctype: Literal['PEC','ModalPort','LumpedPort','PMC','LumpedElement','RectangularWaveguide','Periodic','FloquetPort','SurfaceImpedance']) -> FaceSelection:
@@ -497,6 +496,8 @@ class ModalPort(PortBC):
         self._first_k0: float | None = None
         self._last_k0: float | None = None
         
+        self.plus_terminal: list[tuple[int, int]] = []
+        self.minus_terminal: list[tuple[int, int]] = []
 
         if cs is None:
             logger.info('Constructing coordinate system from normal port')
@@ -522,6 +523,26 @@ class ModalPort(PortBC):
             *axes (tuple, np.ndarray, Axis): The alignment vectors.
         """ 
         self.alignment_vectors = [_parse_axis(ax) for ax in axes]
+    
+    def set_terminals(self, positive: Selection | GeoObject | None = None,
+                      negative: Selection | GeoObject | None = None,
+                      ground: Selection | GeoObject | None = None) -> None:
+        """Define which objects/faces/selection should be assigned the positive terminal
+        and which one the negative terminal.
+        
+        The terminal assignment will be used to find an integration line for the impedance calculation.
+
+        Note: Ground is currently unused.
+        
+        Args:
+            positive (Selection | GeoObject | None, optional): The postive terminal. Defaults to None.
+            negative (Selection | GeoObject | None, optional): The negative terminal. Defaults to None.
+            ground (Selection | GeoObject | None, optional): _description_. Defaults to None.
+        """
+        if positive is not None:
+            self.plus_terminal = positive.dimtags
+        if negative is not None:
+            self.minus_terminal = negative.dimtags
         
     @property
     def nmodes(self) -> int:
@@ -569,9 +590,10 @@ class ModalPort(PortBC):
         Returns:
             PortMode: The requested PortMode object
         """
+        options = self.modes[min(self.modes.keys(), key=lambda k: abs(k - k0))]
         if i is None:
-            i = self.selected_mode
-        return self.modes[min(self.modes.keys(), key=lambda k: abs(k - k0))][i]
+            i = min(len(options)-1, self.selected_mode)
+        return options[i]
     
     def global_field_function(self, k0: float = 0, which: Literal['E','H'] = 'E') -> Callable:
         ''' The field function used to compute the E-field. 
@@ -805,7 +827,7 @@ class LumpedPort(PortBC):
                  port_number: int, 
                  width: float | None = None,
                  height: float | None = None,
-                 direction: Axis | None = None,
+                 direction: Axis | tuple[float, float, float] | None = None,
                  power: float = 1,
                  Z0: float = 50):
         """Generates a lumped power boundary condition.
@@ -843,7 +865,7 @@ class LumpedPort(PortBC):
         
         self.width: float = width
         self.height: float = height # type: ignore
-        self.Vdirection: Axis = direction # type: ignore
+        self.Vdirection: Axis = _parse_axis(direction) # type: ignore
         self.type = 'TEM'
         
         # logger.info('Constructing coordinate system from normal port')

emerge/_emerge/physics/microwave/microwave_data.py

@@ -18,7 +18,7 @@
 from __future__ import annotations
 from ...simulation_data import BaseDataset, DataContainer
 from ...elements.femdata import FEMBasis
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 import numpy as np
 from typing import Literal
 from loguru import logger
@@ -372,6 +372,7 @@ class EHField:
     freq: float
     er: np.ndarray
     ur: np.ndarray
+    aux: dict[str, np.ndarray] = field(default_factory=dict)
 
     @property
     def k0(self) -> float:
@@ -537,7 +538,7 @@ class EHField:
         
         return self.x, self.y, self.z, Fx, Fy, Fz
     
-    def scalar(self, field: Literal['Ex','Ey','Ez','Hx','Hy','Hz','normE','normH'], metric: Literal['abs','real','imag','complex'] = 'real') -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
+    def scalar(self, field: Literal['Ex','Ey','Ez','Hx','Hy','Hz','normE','normH'] | str, metric: Literal['abs','real','imag','complex'] = 'real') -> tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
         """Returns the data X, Y, Z, Field based on the interpolation
 
         For animations, make sure to select the complex metric.
@@ -549,7 +550,11 @@ class EHField:
         Returns:
             (X,Y,Z,Field): The coordinates plus field scalar
         """
-        field_arry = getattr(self, field)
+        if field in self.aux:
+            field_arry = self.aux[field]
+        else:
+            field_arry = getattr(self, field)
+        
         if metric=='abs':
             field = np.abs(field_arry)
         elif metric=='real':
@@ -666,6 +671,10 @@ class MWField:
         self.excitation = {key: 0.0 for key in self._fields.keys()}
         self.excitation[self.port_modes[0].port_number] = 1.0 + 0j
 
+    def excite_port(self, number: int) -> None:
+        self.excitation = {key: 0.0 for key in self._fields.keys()}
+        self.excitation[self.port_modes[number].port_number] = 1.0 + 0j
+        
     @property
     def EH(self) -> tuple[np.ndarray, np.ndarray]:
         ''' Return the electric and magnetic field as a tuple of numpy arrays '''
@@ -726,12 +735,29 @@ class MWField:
         self.Hx = Hx.reshape(shp)
         self.Hy = Hy.reshape(shp)
         self.Hz = Hz.reshape(shp)
-
+        
         self._x = xs
         self._y = ys
         self._z = zs
-        return EHField(xs, ys, zs, self.Ex, self.Ey, self.Ez, self.Hx, self.Hy, self.Hz, self.freq, self.er, self.ur)
-
+        field = EHField(xs, ys, zs, self.Ex, self.Ey, self.Ez, self.Hx, self.Hy, self.Hz, self.freq, self.er, self.ur)
+        
+        return field
+    
+    def _solution_quality(self) -> tuple[np.ndarray, np.ndarray]:
+        from .adaptive_mesh import compute_error_estimate
+        
+        error_tet, max_elem_size = compute_error_estimate(self)
+        return error_tet, max_elem_size
+        
+    def boundary(self,
+                 selection: FaceSelection) -> EHField:
+        nodes = self.mesh.nodes
+        x = nodes[0,:]
+        y = nodes[1,:]
+        z = nodes[2,:]
+        field = self.interpolate(x, y, z, False)
+        return field
+    
     def cutplane(self, 
                      ds: float,
                      x: float | None = None,